Javatpoint Logo
Javatpoint Logo

Multicast d?l?gat?s in C#

Introduction:

In C#, d?l?gat?s s?rv? as pow?rful m?chanisms for impl?m?nting th? obs?rv?r d?sign patt?rn, ?nabling obj?cts to notify multipl? obs?rv?rs about chang?s or ?v?nts. Th? fundam?ntal rol? of d?l?gat?s is to cr?at? m?thod point?rs, acting as r?f?r?nc?s to functions and facilitating th? impl?m?ntation of loos?ly coupl?d syst?ms. This d?sign patt?rn promot?s fl?xibility and ?xt?nsibility in softwar? archit?ctur?s.

Th? obs?rv?r patt?rn involv?s a subj?ct that maintains a list of d?p?nd?nts, known as obs?rv?rs, and notifi?s th?m of any stat? chang?s, ?nsuring a consist?nt and d?coupl?d communication flow. D?l?gat?s play a pivotal role in this patt?rn by providing a typ?-saf? and ?ncapsulat?d m?ans to r?pr?s?nt m?thod signatur?s. A singl?cast d?l?gat? allows a on?-to-on? mapping b?tw??n a d?l?gat? instanc? and a m?thod, but th? r?al pow?r ?m?rg?s with multicast d?l?gat?s.

Multicast d?l?gat?s ?xt?nd th? capabiliti?s of singl?cast d?l?gat?s by allowing a d?l?gat? to point to and invok? multipl? m?thods. This f?atur? is particularly valuabl? in sc?narios wh?r? an ?v?nt or chang? r?quir?s notification to multipl? subscrib?rs. Using th? += and -= op?rators, d?v?lop?rs can ?asily combin? or r?mov? m?thods from th? invocation list of a multicast d?l?gat?.

The practical application of multicast d?l?gat?s is ?vid?nt in ?v?nt handling syst?ms. For instance, in graphical us?r int?rfac?s or distribut?d syst?ms, an obj?ct can us? a multicast d?l?gat? to notify multipl? list?n?rs wh?n a sp?cific ?v?nt occurs. This ?nhanc?s th? modularity of th? cod?bas?, as various compon?nts can ind?p?nd?ntly r?spond to ?v?nts without ?xplicit knowl?dg? of on? anoth?r.

D?finition of Multicast D?l?gat?s:

A multicast d?l?gat? in C# is an instanc? of th? Syst?m. D?l?gat? class that ?xt?nds th? functionality of a singl?cast d?l?gat?. Whil? a singl?cast d?l?gat? can r?f?r?nc? only on? m?thod, a multicast d?l?gat? can point to and invok? multipl? m?thods. Its purpose is to facilitat? ?ffici?nt ?v?nt handling and th? impl?m?ntation of th? obs?rv?r d?sign patt?rn.

Multicast d?l?gat?s ?nabl? an obj?ct to notify multipl? oth?r obj?cts about chang?s or ?v?nts. Th?y maintains an ord?r?d list (invocation list) of m?thods and wh?n invok?d, all m?thods in th? list ar? call?d s?qu?ntially. This capability promotes modularity, ?xt?nsibility, and d?coupling in ?v?nt-driv?n archit?ctur?s, ?nhancing th? fl?xibility of C# programming.

Und?rstanding D?l?gat?s:

Und?rstanding d?l?gat?s in C# is ?ss?ntial for l?v?raging th?ir pow?r in cr?ating fl?xibl? and ?xt?nsibl? cod?. D?l?gat?s ar? a typ?-saf?, obj?ct-ori?nt?d m?chanism that ?nabl?s you to tr?at m?thods as first-class citiz?ns, allowing you to pass m?thods as param?t?rs, r?turn m?thods from oth?r m?thods, and stor? r?f?r?nc?s to m?thods in variabl?s.

D?l?gat? D?finition:

  • A d?l?gat? is a r?f?r?nc? typ? that holds th? r?f?r?nc? (point?r) to a m?thod.
  • It d?fin?s a m?thod signatur?, sp?cifying th? r?turn typ? and param?t?r typ?s.

D?l?gat? Instanc?s:

  • Onc? a d?l?gat? typ? is d?fin?d, you can cr?at? instanc?s of that typ?.
  • D?l?gat? instanc?s ar? lik? obj?ct instanc?s, and th?y can r?f?r?nc? m?thods that match th? sp?cifi?d signatur?.

M?thod Signatur?s:

D?l?gat?s provid? a l?v?l of abstraction for m?thod signatur?s, allowing you to ?ncapsulat? th? d?tails of a m?thod's param?t?rs and r?turn typ?.

Multicast D?l?gat?s:

  • Multicast d?l?gat?s can point to and invok? multipl? m?thods.
  • Th?y us? th? += and -= op?rators to add or r?mov? m?thods from th?ir invocation list.

Purpos?:

Ev?nt Handling:

Multicast d?l?gat?s ar? commonly used in ?v?nt handling sc?narios. For ?xampl?, in graphical us?r int?rfac?s or distribut?d syst?ms, an obj?ct can notify multiple subscrib?rs about an ?v?nt using a multicast d?l?gat?. Each subscrib?r's m?thod is add?d to th? d?l?gat?'s invocation list, and wh?n th? ?v?nt occurs, all subscrib?d m?thods ar? invok?d.

Obs?rv?r D?sign Patt?rn:

Multicast d?l?gat?s facilitat? th? impl?m?ntation of th? obs?rv?r d?sign patt?rn in C#. In this patt?rn, an obj?ct (th? subj?ct) maintains a list of d?p?nd?nts (obs?rv?rs) that ar? notifi?d of any stat? chang?s. Multicast d?l?gat?s provide an ?ffici?nt way to manage this list of obs?rv?rs.

By allowing a d?l?gat? to point to and invok? multipl? m?thods, multicast d?l?gat?s ?nabl? th? subj?ct to notify multipl? obs?rv?rs simultan?ously. This promotes a str?amlin?d and modular approach to handling ?v?nts and updat?s, ?nhancing th? fl?xibility and maintainability of cod? in sc?narios wh?r? multipl? obj?cts n??d to r?act to chang?s in a subj?ct's stat?.

Loos? Coupling:

Utilizing multicast d?l?gat?s promot?s loos? coupling b?tw??n compon?nts in C#. An obj?ct can publish ?v?nts without n??ding knowl?dg? of which ?ntiti?s will r?spond. Subscrib?rs can ind?p?nd?ntly attach or d?tach from th? multicast d?l?gat?, fost?ring fl?xibility and ?xt?nsibility in th? syst?m. This d?coupling ?nhanc?s modularity, as th? publish?r and subscrib?rs op?rat? ind?p?nd?ntly, minimizing d?p?nd?nci?s.

Th? multicast d?l?gat? acts as an int?rm?diary, allowing s?aml?ss communication b?tw??n compon?nts without ?xplicit conn?ctions. This archit?ctural approach supports scalability and adaptability, ?nabling th? dynamic addition or r?moval of functionality without r?quiring ?xt?nsiv? modifications, contributing to a mor? maintainabl? and robust cod?bas? in ?v?nt-driv?n sc?narios.

S?qu?ntial Ex?cution:

Th? ord?r of m?thod addition to a multicast d?l?gat? in C# holds critical significanc?, as it directly influ?nc?s th? s?qu?nc? of m?thod ?x?cution upon invocation. This is particularly crucial in sc?narios lik? pip?lin?s or chains of r?sponsibility, wh?r? th? ord?r of op?rations impacts th? ov?rall outcom?.

Multicast d?l?gat?s ?nsur? that m?thods ?x?cut? in th? pr?cis? ord?r th?y w?r? add?d, allowing d?v?lop?rs to ?stablish d?lib?rat? s?qu?nc?s in compl?x proc?ss?s. This ord?r?d ?x?cution m?chanism ?nhanc?s control and pr?dictability in sc?narios wh?r? th? flow of op?rations is ?ss?ntial to achi?v? d?sir?d functionality or b?haviour.

Cod? Modularity:

Multicast d?l?gat?s in C# significantly boost cod? modularity by facilitating th? cr?ation of compon?nts capabl? of autonomously r?sponding to ?v?nts. This d?sign allows compon?nts to op?rat? without ?xplicit knowl?dg? of ?ach oth?r, fost?ring a d?coupl?d and modular cod?bas?. As a result, changes to one compon?nt do not n?c?ssitat? modifications in others, ?nhancing maintainability.

This d?coupling promot?s a fl?xibl? and scalabl? archit?ctur?, wh?r? individual compon?nts, unawar? of ?ach oth?r's impl?m?ntations, can s?aml?ssly int?ract through multicast d?l?gat?s, contributing to a mor? modular and r?sili?nt softwar? d?sign.

Program:

Output:

Addition: 15
Subtraction: 5
Multiplication: 50
Division: 2

Explanation:

Class Structur?:

Th? cod? d?fin?s two class?s - Calculator and Arithm?ticProgram.

  • Calculator Class:

Th? Calculator class s?rv?s as a compr?h?nsiv? ?ncapsulation of m?thods, providing fundam?ntal arithm?tic op?rations within th? C# cod?. It includes m?thods for addition, subtraction, multiplication, and division, allowing for a v?rsatil? rang? of num?rical computations.

Each m?thod follows a consistent patt?rn, taking two int?g?r param?t?rs, ?x?cuting th? corr?sponding arithm?tic op?ration, and r?turning th? r?sult. This modular structure promotes cod? organization, r?adability, and ?as? of maint?nanc?.

Th? Divid? m?thod within th? Calculator class incorporat?s ?ss?ntial ?rror handling to pr?v?nt division by z?ro. In cases wh?r? th? divisor is z?ro, it prints an ?rror m?ssag? to th? consol?, d?monstrating a proactiv? approach to addr?ss potential runtim? issues and ?nhanc? program robustn?ss.

  • Arithm?ticProgram Class:

Th? Arithm?ticalProgram class s?rv?s as th? ?ntry point for th? program, containing th? Main m?thod. This m?thod initializ?s two int?g?r variabl?s, num1 and num2, with valu?s such as 10 and 5. Subs?qu?ntly, Consol?.Writ?Lin? stat?m?nts illustrat? th? usag? of Calculator m?thods, showcasing arithm?tic op?rations such as addition, subtraction, multiplication, and division. Th? program th?n ?mploys Consol?.R?adLin?() to await us?r input, ?nsuring th? consol? window r?mains op?n for us?r int?raction.

Arithm?tic Op?rations:

Th? cor? functionality of th? cod? r?volv?s around p?rforming fundam?ntal arithm?tic op?rations, ?ach ?ncapsulat?d within th? Calculator class.

  • Addition:

Th? Add m?thod s?rv?s to add two int?g?r valu?s, off?ring a straightforward op?ration that sums th? input valu?s and r?turns th? r?sult. It provides a fundam?ntal building block for num?ric addition within th? cont?xt of th? calculator.

  • Subtraction:

Subtraction, impl?m?nt?d by th? Subtract m?thod, calculat?s th? diff?r?nc? b?tw??n th? first and s?cond int?g?r valu?s, r?turning th? r?sult. This op?ration is crucial for sc?narios wh?r? subtracting on? valu? from anoth?r is r?quir?d, forming a foundational arithm?tic op?ration.

  • Multiplication:

Multiplication, handl?d by th? Multiply m?thod, facilitat?s th? product of two int?g?r valu?s. This op?ration is fundam?ntal in sc?narios wh?r? r?p?at?d addition is str?amlin?d into a singl? op?ration, contributing to th? ov?rall ?ffici?ncy of th? calculator.

  • Division:

Th? Divid? m?thod manag?s division, ?nsuring that th? divisor is non-z?ro to avoid division by z?ro ?rrors. It r?turns th? quoti?nt wh?n th? divisor is non-z?ro; oth?rwis?, it prints an ?rror m?ssag?. This m?thod is ?ss?ntial for handling division op?rations, incorporating a saf?guard to pr?v?nt und?fin?d r?sults.

Usag? in Main M?thod:

Th? Main m?thod of th? Arithm?ticProgram class showcas?s th? practical application of th? Calculator class m?thods:

  • Variabl? Initialization:

Two int?g?r variabl?s, num1 and num2, ar? initializ?d with valu?s (10 and 5, r?sp?ctiv?ly).

  • M?thod Invocation:

Th? Consol?.Writ?Lin? stat?m?nts invok? th? Calculator m?thods to p?rform diff?r?nt arithm?tic op?rations on num1 and num2.

Th? r?sults ar? print?d to th? consol?.

  • Error Handling:

Th? Divid? m?thod d?monstrat?s ?rror handling by ?nsuring that division by z?ro is avoid?d, and an appropriate m?ssag? is print?d in cas? of such an att?mpt.

  • Consol? Output:

The output of th? program displays th? results of th? arithm?tic op?rations, providing a visual r?pr?s?ntation of th? calculations p?rform?d.

Compl?xity Analysis:

Analyzing th? tim? and spac? compl?xity of th? provid?d C# cod? involv?s ?valuating th? ?ffici?ncy of its op?rations and m?mory usag?. L?t's br?ak down th? tim? and spac? compl?xity asp?cts.

Tim? Compl?xity Analysis:

Arithm?tic Op?rations (Add, Subtract, Multiply, Divid? m?thods):

Th? tim? compl?xity of th? arithm?tic op?rations is O(1). Th?s? m?thods p?rform simpl? math?matical op?rations that tak? a constant amount of tim? r?gardl?ss of th? input valu?s. Th? tim? compl?xity r?mains constant for addition, subtraction, multiplication, and division.

Main M?thod Ex?cution:

Th? tim? compl?xity of th? Main m?thod is also O(1). It consists of constant-tim? op?rations, such as variabl? initialization, m?thod invocations, and consol? output. Th? ?x?cution tim? is not influ?nc?d by th? siz? of th? input.

Error Handling (Divid? M?thod):

Th? ?rror handling in th? Divid? m?thod involv?s a conditional ch?ck for division by z?ro. In th? worst case, wh?n division by z?ro occurs, th? tim? compl?xity is O(1). Th? ch?ck and th? subs?qu?nt ?rror m?ssag? printing ar? constant-tim? op?rations.

Consol? Output:

Th? tim? compl?xity for printing to th? consol? using Consol?.Writ?Lin? stat?m?nts is O(1). Output op?rations ar? g?n?rally consid?r?d constant tim?, as th?y don't d?p?nd on th? siz? of th? input.

Th? total tim? compl?xity of th? provid?d cod? is influ?nc?d by th? arithm?tic op?rations and th? Divid? m?thod's ?rror handling. Sinc? th?s? op?rations ar? O(1) and occur s?qu?ntially, th? dominant factor for tim? compl?xity is O(1).

Spac? Compl?xity Analysis:

Arithm?tic Op?rations (Add, Subtract, Multiply, Divid? m?thods):

The spac? compl?xity of th? arithm?tic op?rations is O(1). Th?s? m?thods us? a constant amount of spac? for variabl?s and t?mporary storag?, and th? spac? r?quir?d do not grow with th? input.

Main M?thod Variabl?s (num1 and num2):

Th? spac? compl?xity for th? int?g?r variabl?s num1 and num2 is O(1). Th?s? variabl?s us? a constant amount of spac? r?gardl?ss of th? input siz?, and th?ir m?mory footprint is not influ?nc?d by th? input valu?s.

Error Handling (Divid? M?thod):

Th? spac? compl?xity for ?rror handling in th? Divid? m?thod is O(1). Th? ?rror m?ssag? printing and th? variabl?s us?d for division r?sult and ?rror ch?ck us? a constant amount of spac?.

Consol? Output:

Th? spac? compl?xity for consol? output is O(1). Th? m?mory r?quir?d to print m?ssag?s to th? consol? is constant and ind?p?nd?nt of th? input siz?.

The total spac? compl?xity of th? cod? is O(1). Th? spac? r?quir?d for variabl?s, t?mporary storag?, and ?rror handling r?mains constant, and th? program's m?mory footprint do?s not grow with th? siz? of th? input.

Limitations and consid?rations:

Multicast d?l?gat?s in C# off?r pow?rful functionality for impl?m?nting ?v?nt-driv?n archit?ctur?s, but lik? any programming construct, th?y com? with c?rtain limitations and consid?rations. Understanding th?s? asp?cts is crucial for writing robust and maintainabl? cod?.

Ex?cution Ord?r and R?turn Valu?s:

Ord?r of Ex?cution: Th? ord?r in which m?thods ar? add?d to th? invocation list of a multicast d?l?gat? d?t?rmin?s th? ord?r in which th?y ar? ?x?cut?d. Whil? this can b? b?n?ficial for c?rtain sc?narios, it may l?ad to subtl? bugs if th? s?qu?nc? of ?x?cution is not w?ll und?rstood or if it is critical to th? program's logic.

R?turn Valu?s: Multicast d?l?gat?s do not r?turn valu?s from th? invok?d m?thods. If a m?thod in th? invocation list has a non-void r?turn typ?, th? r?turn valu? of th? last m?thod in th? list is ?ff?ctiv?ly th? r?turn valu? of th? ?ntir? invocation. This behaviour may not be intuitiv? and could lead to un?xp?ct?d results.

Immutabl? Invocation List:

The invocation list of a multicast d?l?gat? in C# is immutabl?. Wh?n m?thods ar? add?d or r?mov?d, a n?w d?l?gat? instanc? is cr?at?d, surprising d?v?lop?rs who ?xp?ct shar?d b?havior among multipl? r?f?r?nc?s to th? sam? d?l?gat?. Modifications to one instanc? don't affect others, as ?ach r?fl?cts a distinct stat?.

This immutability ?nsur?s stability during ?x?cution, pr?v?nting unint?nd?d sid? ?ff?cts across r?f?r?nc?s. D?v?lop?rs should b? mindful of this b?havior to manag? d?l?gat? instanc?s ?ff?ctiv?ly, promoting pr?dictability in cod? b?havior and avoiding un?xp?ct?d cons?qu?nc?s in sc?narios involving shar?d d?l?gat?s.

Thr?ad Saf?ty:

Multicast d?l?gat?s ar? not inh?r?ntly thr?ad-saf?. Wh?n m?thods ar? add?d or r?mov?d from a multicast d?l?gat? from multipl? thr?ads, rac? conditions may occur. D?v?lop?rs must us? synchronization m?chanisms such as locks or oth?r thr?ad synchronization primitiv?s to ?nsur? saf? manipulation of multicast d?l?gat?s in a multi-thr?ad?d ?nvironm?nt.

Typ? Saf?ty:

Whil? d?l?gat?s in C# ar? inh?r?ntly typ?-saf?, combining th?m into a multicast d?l?gat? introduc?s a pot?ntial for typ?-r?lat?d issu?s. If th? m?thods within th? invocation list poss?ss diff?r?nt param?t?r typ?s than th? d?l?gat?'s signatur?, it can l?ad to runtim? ?rrors. Att?mpting to invok? such a multicast d?l?gat? may r?sult in an InvalidCastExc?ption.

This risk und?rscor?s th? importanc? of ?nsuring consist?ncy in m?thod signatur?s within th? invocation list to maintain typ? saf?ty. D?v?lop?rs should ?x?rcis? caution and adh?r? to a uniform m?thod signatur? wh?n aggr?gating d?l?gat?s to pr?v?nt runtim? ?xc?ptions, promoting robust and ?rror-r?sistant cod? in ?v?nt-driv?n archit?ctur?s.

M?mory Manag?m?nt:

Wh?n a multicast d?l?gat? is no longer n??d?d, it's important to ?nsur? prop?r m?mory manag?m?nt. Unlik? simpl? obj?cts, d?l?gat?s may r?f?r?nc? m?thods, pr?v?nting automatic garbag? coll?ction if r?f?r?nc?s ar? r?tain?d long?r than n?c?ssary. Explicitly s?tting th? d?l?gat? to null can aid in tim?ly garbag? coll?ction.

D?l?gat? Chain L?ngth:

As mor? m?thods ar? add?d to a multicast d?l?gat?, th? l?ngth of th? invocation chain incr?as?s. In sc?narios wh?r? th?r? ar? a larg? numb?r of subscrib?rs, th? p?rformanc? impact of invoking a long chain of m?thods should b? consid?r?d. Exc?ssiv? d?l?gat? chaining may r?sult in d?cr?as?d p?rformanc? and r?sponsiv?n?ss.

D?bugging Chall?ng?s:

D?bugging cod? involving multicast d?l?gat?s can be challenging, ?sp?cially when dealing with long invocation lists. St?pping through th? ?x?cution of ?ach m?thod in th? list may b? cumb?rsom?, making it important to adopt cl?ar coding practices and us? d?bugging tools ?ff?ctiv?ly.

Us?cas?s of Multicast D?l?gat?s:

Multicast d?l?gat?s in C# find v?rsatil? applications across various softwar? d?v?lopm?nt sc?narios, off?ring a fl?xibl? and d?coupl?d way to handl? ?v?nts, notifications, and oth?r callback m?chanisms. Whil? actual cod? impl?m?ntations provid? concr?t? ?xampl?s, und?rstanding th? us? cas?s without cod? is ?ss?ntial for appr?ciating th? broad?r archit?ctural and d?sign implications.

Ev?nt Handling:

One of the th? primary us? cas?s for multicast d?l?gat?s is ?v?nt handling. In ?v?nt-driv?n programming, obj?cts oft?n n??d to notify multipl? subscrib?rs about chang?s or occurr?nc?s. Multicast d?l?gat?s simplify this process by allowing an obj?ct to maintain a list of m?thods (?v?nt handl?rs) to b? invok?d when a sp?cific ?v?nt occurs. Subscrib?rs can th?n add or r?mov? th?ir m?thods to or from th? multicast d?l?gat?, ?stablishing a cl?an and ?xt?nsibl? m?chanism for handling ?v?nts.

Obs?rv?r D?sign Patt?rn:

Multicast d?l?gat?s ar? a natural fit for impl?m?nting th? obs?rv?r d?sign patt?rn. In this patt?rn, an obj?ct (th? subj?ct) maintains a list of d?p?nd?nts (obs?rv?rs) that ar? notifi?d of any stat? chang?s. Multicast d?l?gat?s can b? us?d to manag? this list ?ffici?ntly. Obs?rv?rs can subscrib? to r?l?vant ?v?nts by adding th?ir m?thods to th? multicast d?l?gat?, and wh?n th? subj?ct und?rgo?s chang?s, all subscrib?d obs?rv?rs ar? notifi?d.

UI Programming:

Graphical us?r int?rfac?s (GUIs) oft?n r?quir? handling us?r actions, such as button clicks or m?nu s?l?ctions, with multipl? handl?rs. Multicast d?l?gat?s facilitat? this sc?nario by allowing different parts of th? UI to r?spond to us?r int?ractions ind?p?nd?ntly. For instance, in a window with multiple controls, ?ach control's behaviour can b? ?ncapsulat?d in a s?parat? m?thod subscrib?d to a multicast d?l?gat? handling th? r?l?vant ?v?nt.

D?coupl?d Communication:

Multicast d?l?gat?s support th? principl? of loos? coupling, ?nabling compon?nts to communicat? without ?xplicit knowl?dg? of ?ach oth?r's impl?m?ntations. This promotes modularity and maintainability in softwar? systems. Compon?nts can subscrib? to ?v?nts using multicast d?l?gat?s, and th? publish?r can notify subscrib?rs without n??ding to know th?ir sp?cific id?ntiti?s or impl?m?ntations.

Chain of Responsibility:

Multicast d?l?gat?s ar? instrum?ntal in impl?m?nting th? Chain of R?sponsibility d?sign patt?rn. In this patt?rn, multipl? handl?rs proc?ss a r?qu?st ind?p?nd?ntly, and th? r?qu?st is pass?d along th? chain until it is handl?d or r?ach?s th? ?nd. Each handl?r subscrib?s to th? multicast d?l?gat? and wh?n an ?v?nt occurs, th? d?l?gat? is invok?d, and ?ach handl?r in th? chain proc?ss?s th? ?v?nt as n??d?d.

Plugin Archit?ctur?s:

In ?xt?nsibl? syst?ms wh?r? plugins or modul?s n??d to r?spond to c?rtain ?v?nts, multicast d?l?gat?s provid? an ?l?gant solution. Each plugin can subscrib? to r?l?vant ?v?nts by adding its m?thod to th? d?l?gat?, ?nabling th? cor? syst?m to notify all plugins wh?n significant ?v?nts occur. This approach allows for dynamic ?xt?nsibility without modifying th? cor? compon?nts.

Asynchronous Programming:

Asynchronous programming oft?n involv?s handling th? compl?tion of asynchronous op?rations. Multicast d?l?gat?s can b? ?mploy?d to manage callbacks from asynchronous tasks. Multipl? m?thods can subscrib? to th? d?l?gat?, and wh?n th? asynchronous op?ration compl?t?s, all subscrib?d m?thods ar? invok?d. This is particularly useful in sc?narios like parall?l programming or handling multiple asynchronous data sources.







Youtube For Videos Join Our Youtube Channel: Join Now

Feedback


Help Others, Please Share

facebook twitter pinterest

Learn Latest Tutorials


Preparation


Trending Technologies


B.Tech / MCA