Designing .NET Class Libraries: Member Types (February 09, 2005)

아티클
01/21/2022

Posted: February 16, 2005

Please note: Portions of this transcript have been edited for clarity

Introduction

frankred [MS] (Moderator):
While you’re getting your questions together, let’s meet our knowledgeable experts.

Brad Abrams [MSFT] (Expert):
Hello from Dallas! I am Brad Abrams, and I gave the training sessions we are discussing today.

Joe Duffy [MS] (Expert):
Hello! Thanks for joining... Looking forward to a great chat. So my name is Joe Duffy, and I work on the CLR PM team. My blog is at https://www.blu ebytesoftware.com/blog/ -- I try to keep it interesting. :) Let the games begin!

Start of Chats

Brad Abrams [MSFT] (Expert):
Q: Do you also cover .NET CF issues here?
A: Well, to the extend the API design issues are the same between CF and .NET Framework yes..

Brad Abrams [MSFT] (Expert):
Q: Is C# internal/VB Friend seen as a "public" or private scope from the perspective of the guidelines? Obviously it's not public external to the assembly, but it is public within the assembly. Or is the boundary at the assembly level?
A: From the DG point of view we focus on things that are visible outside the assembly we assume anyone that can is inside your assembly you have some special relationship with (a la they sit right next to you) and thus the requirements for the DG are not as strong.

Krzysztof Cwalina (Expert):
Hi. This is Krzysztof Cwalina. Sorry for being 5 minutes late.

Joe Duffy [MS] (Expert):
Q: Hi, why was the decision made not to support const parameter passing?
A: Basically, it's tough to keep type safety and still get it right. You would have to limit it to const ref parameters (since everything's byval by default). Given that in most scenarios you're working with objects which might need to be "read only," it didn't seem like a scenario that would be super useful. You can acheive much of the same thing using structs.

Brad Abrams [MSFT] (Expert):
Q: DG?
A: Sorry, Design Guidelines. That is the name we use for the set of rules that covers public API design that we are discussing here today

Brad Abrams [MSFT] (Expert):
Q: I discovered this great resource for my development. https://msdn.microsoft.com/netframework/programming/classlibraries/#CurrentAndFuturePresentations there is an entry named Designing Inheritance Hierarchies By: Brad Abrams it states
A: Well great! That will be posted this end of this week and we will have a chat on it a week from today.

Joe Duffy [MS] (Expert):
Q: Does .NET can connect to databases (like MS SQL for example) on a external server?
A: Yes. The System.Data namespace contains a whole set of classes which enable you to connect to SQL Server, Oracle, ... basically any ODBC data source. See https://msdn.microsof t.com/data/ for more information. This is a dev center dedicated to this very topic.

Krzysztof Cwalina (Expert):
Q: in com dll libraries you must register before used it, with net class libraries that is not needed ?
A: When a CLR execution starts, the CLR tries to load all dependencies it was compiled with. It looks for these dependencies in the local directory of the exe first. If it finds the dependency there all works just fine without a need for registrations. If the dependency is not in the local directory it looks in the GAC (global assembly cache). Assemblies stored in the GAC need to be registered.

Krzysztof Cwalina (Expert):
Q: Are there any tips you have in mind that would like to share with us?
A: Armen, what kind of tips are you looking for?

Brad Abrams [MSFT] (Expert):
Q: In the talk there was mention of overloading, particularly in constructors. Something I took away with me was to also have a related property for each parameter and have a default constructor. Why are default parameters (ala C++) not supported in the FX?
A: In general for language design we have the a philosophy called “addition through subtraction”. That is to say there is some inherent value in not having a feature. There is less to learn, document, understand, etc. So a feature has to way more than pay for itself to get into the language. While default parameters are an interesting language feature, that don’t add enough value to be worth the complexity they introduce.

Joe Duffy [MS] (Expert):
Q: When reviewing a method which takes a lot of parameters (say a constructor), is there a cutoff to the number of parameters you look at before recommend changing to a struct/class?
A: We have a number of guidelines around trying to reduce complexity of parameter sizes. Really, if you start to have more than 3-4 for your simplest overload, you should look at ways to reduce the size. One way to do this is to have "smart" defaults for the parameters so users don't have to supply them. Another is to force somebody to set properties afterwards in the case of a ctor. Lastly, as you indicated, you could wrap things up in a smaller object. But you still have to construct the object (which presumably involves setting all these fields anyhow), so this doesn't necessarily simplify life.

Krzysztof Cwalina (Expert):
Q: Is there a "viewer" to look a the contents of the GAC ?
A: There is a command line tool that ships with the .NET Framework SDK. It's called gacutil.exe. Also, I am pretty sure I have seen some shell extensions for the GAC, but I am not sure where it was.

Brad Abrams [MSFT] (Expert):
Q: are there changes to how methods or properties are compiled or jitted that would reflect changes to the guidelines for Methods vs Properties in 2.0? I would guess not, since the principles regarding Methods vs Props are OOP oriented and not .net specific
A: Your intuition is right - we did not change anything fundamental with the CLR in how properties and methods work. What we are doing is making sure that simple getters\setters (and even simple methods) can be inlined is a performance benefit.

Brad Abrams [MSFT] (Expert):
Q: To a new user (like me) what do you recommand before start to work?
A: go check out https://msdn. microsoft.com/netframework/

Joe Duffy [MS] (Expert):
Q: Joe, coming from a C++ background, I found it quite reassuring that an object that I pass to an API was gauranteed to be free from modification. Are there any plans in the future to represent constness, either in IL or C#?
A: I entirely agree. But in general, it's hard to get right in encapsulated systems. Value types already have these semantics, as you can't pass a ref to one (it ends up being a ref to the boxed object). So, it's very similar. But for reference types, it's difficult to enforce this. For example, how do you know that calling a particular method will end up modifying state? Preventing property or field sets is one way, but there are a whole host of other ways to mutate state. I know there are a lot of research efforts around how to do this correctly--i.e. describing better the effects of method calls--but I wouldn't expect any changes to C# or IL in this regard in the _near_ future.

Krzysztof Cwalina (Expert):
Q: FxCop - How often do changes occur in the Design Guidelines and what effort is made to keep FxCop "rules" in sync? How are these handled?
A: We add new guidelines or augment existing guidelines quite often. I would say every 2 weeks on averag we have some update. But we rarely change existing guidelines such that code that used to follow the guideline is now no compliant. We try to keep FxCop in sync with the updates, but there may be cases where a guideline is not turned into a rule for a long time or when a rule is not updated when a guideline is updated.

Brad Abrams [MSFT] (Expert):
Q: There is some difference between vb net aplication and asp net application on this subject ?
A: Nope that is the beauty of good framework design - it transcends application models (WinForms, ASP.NET, Avalon) and programming languages (C++, C#, VB, Python).

Brad Abrams [MSFT] (Expert):
Q: in asp net i must put my libraries inside bin directory ?
A: Yup, but that is more about how the library is deployed than how it is designed... You can also put your library in the GAC and ASP.NET can access it...

Joe Duffy [MS] (Expert):
Q: Whats the difference between sending an Object variable type as ByVal and ByRef? Objects pass by reference by default. So what if I pass an object as parameter to a function and pass it as ByRef?
A: Actually, objects are really by value as default. This is tough to get your head around at first. But, if you look at an object variable as just being a pointer to a real object, then when you pass it to a method, you're really passing a *copy* of the pointer's value. That is, the pointer refers to the same object. If the method were to try to change the argument, it wouldn't modify the original pointer. If you pass byref, though, the method receives a reference to the *pointer* which they can then dereference to get the object; but, they can also change the value of that pointer, affecting the code which called the method (like pointing it to an entirely different object). If I didn't explain it clearly enough, let me know... I can probably dig up some references for you.

Brad Abrams [MSFT] (Expert):
Q: Anything perhaps related to .NET 2.0 framework? I saw a webcast on channel9 site with regards to static classes and how they came to be, from a bug that was missed out in declaring a method as static.
A: While all of this material is still very valid in V2.0, there are some new areas to talk about such as generics. We have a whole new set of guidelines around generic’s usage… And as you say some of the guidelines (such as static classes) have been formalized into language support.

Krzysztof Cwalina (Expert):
Q: Is it better to construct an object through the use of large numbers of parameters (I know I know its ugly) or by creating an instance of the object then setting values (from a performance standpoint is there any difference?)
A: Form purely performance point of view, passing lots of parameters to a constructor is faster. But I think one of the most important design skills is to be able to make tradeoffs. I would say that in tish case the APIs has to be extremly low level (high perf requirements and used by a very small number of people) to be worth optimizing perf on such level.

Brad Abrams [MSFT] (Expert):
Q: As part of 2.0 spec, will getter/setter of a property have different accessibility. Like a public get and protected set. ya, you can always work around with an additional method!
A: Yes, it is being added and we are working on updating the DG for this... But to be honest I agree with you, you could always work around this with an additional method... But we are likely updating the CLS to include it.

Joe Duffy [MS] (Expert):
Q: Thanks Joe, I had one more question from the const brigade, and that was, are there are plans to describe whole const methods (public Method( ) const { }), but I think your previous answer applies to this too
A: Yeah... This is essentially what I was describing. We'd love to be able to make better guarantees about side- effects, pre- and post-conditions. But requiring new language syntax and even more modifiers when creating methods is a difficult tradeoff, and one which can be particularly debatable. It's similar to whether you add static type annotations or not... some say it clutters up the language, others like the static safety it provides. I see const as falling into this category.

frankred [MS] (Moderator):
Q: do you have a link to the DG = design guidelines./??
A: Sure. https://msdn.microsoft.com/netframework/programming/classlibrar ies/membertypes/default.aspx?pull=/library/en-us/cpgenref/html/cpconnetframeworkdesignguidelines.asp

Joe Duffy [MS] (Expert):
Q: How can i put my library in the GAC ?
A: There's a utility that is in the .NET Framework SDK, called gacutil.exe. You can read more about it here: https://msdn.microsoft.com/library/en- us/cptools/html/cpgrfGlobalAssemblyCacheUtilityGacutilexe.a sp, and there's some more info in the article here: https://msdn.microsoft.com/library/en-us/dndotnet/html/assenamesp.asp

Krzysztof Cwalina (Expert):
Q: Are there any plans for finer grained inhertance? I particularaly miss protected and private inheritance
A: I am with you on this one. I help WinFx teams to design their APIs and we run very often into cases where private inheritance would help in greatly simplifying the object model. They issue has be raised several times internally, but I think now is the point where I will make a stronger pitch for the feature. We will see.

Brad Abrams [MSFT] (Expert):
Q: what advice do you have for designing a 1.1 class library that may be called from 2.0 code? do's and dont's?
A: If you are going to do this then you are going to have to run your V1.1 library under the V2.0 CLR.. This should work well as we test the CLR for compatibility with 1.0 \1.1. But there were a few changes mostly related to security or reliability that we felt like we had to make - those could break your 1.1 code. So you should check out the information here: https://blogs.msdn.com/b/brada/archive/2005/02/21/377628.aspx and test it out on the 2.0 betas. Hope that helps.

Brad Abrams [MSFT] (Expert):
Q: What is your view on Optional parameters in VB, and why use those versus just creating the overloaded methods. Is there a preferred way?
A: It depends on what you are using them for. For frameworks where you expect callers from multiple different languages you should prefer method overloading as it is supported in the CLS… With optional parameters many languages don’t support them so it would be ugly to use your library from them. If you all your callers are in VB, then the only issue is a versioning one… those optional values get burned in at the call site.

Joe Duffy [MS] (Expert):
Q: What is your view on Optional parameters in VB, and why use those versus just creating the overloaded methods. Is there a preferred way?
A: I personally think they are a useful innovation. The runtime and IL actually have explicit support for optional parameters, so it's nice that the language takes advantage of it. If you're working in VB, definitely take advantage of them. From a micro-perf standpoint, they avoid making unnecessary method calls (compared to an overload which just forwards).

Krzysztof Cwalina (Expert):
Q: when exactly we shld keep abstract calss in our design over interface?
A: I believe there are only two cases when you want to use an interface: 1) you need a mixin (a.k.a. multiple inheritance). For example IDisposable types need to be usually parts of some other hierarchy. 2) If you need a common APIs for reference and value types (as value types cannot inherit). For example, IFormatable is an interface so Int32 and Int64 can be both formatable. A rule of thumb I use is that if something ends with "able" it probably should be an interface. Otherwise it should be a class. I posted blog related to this on https://blogs.msdn.com/kcwalina/archive/2004/10/24/246947.aspx

Krzysztof Cwalina (Expert):
Q: With the arrival of Generics -- does this indicate that perhaps there will be a full port of STL into the managed world?
A: Do you literaly mean STL? If yes, then the C++ team has been thinking about something but I don't know the details. If you mean any collection library based on Generics, then yes. We have them in Whidbey in System.Collections.Generic. If you mean STL like approach to the design of the standard collection libraries then no.

Joe Duffy [MS] (Expert):
Q: java has instance inner classes and static inner classes. .NET has nested classed which are similar to java's static inner classes. Where would you use an inner class that belongs to an outer instance rather than outer class? Was this considered?
A: If I understand correctly, you're asking in general when you would use inner classes? The primary thing that inner classes buy you is scope and visibility. If you need a class to have intimite knowledge of its enclosing outer class, they are appropriate. Likewise, if you are creating a little helper class which is completely isolated inside an outer class (i.e. it never hands out a reference to it, and it's not public), then using this improves encapsulation, too.

Krzysztof Cwalina (Expert):
Q: Thanks Krzysztof. Let me know if you need backing (I can pretend to be several people if need be!)
A: It would be great if you could file a request on MSDN feedback. Thanks!

Brad Abrams [MSFT] (Expert):
Q: How Often We use [Serializable] in a windows application (Not Remoting ) for Objects ?
A: How often? Well, it all depends on the scenario. You should not mark types serializable unless you have a clear reason to.

Brad Abrams [MSFT] (Expert):
Q: How Often we have to use [Serializable] for our objects in a simple Application (Not in remotings , I know the application in Remoting apps ) ?
A: Same answer... what is the senario? Did you consider Xml Serialization?

Joe Duffy [MS] (Expert):
Q: Joe, can you elaborate on the micro-perf standpoint regarding how optional parameters work internally?
A: Sure. Basically, the VBC will bake in the defaults to the callsite so that an additional method call isn't needed to create and forward the arguments. If you look at the metadata (using ildasm, for example), you can see that there's a default parameter token which specifies the default value--when making a call where you haven't supplied all of the args, the VB compiler sees this, and automatically loads the right value before callign the method. It's all done in static source, so there's no runtime hit.

Joe Duffy [MS] (Expert):
Q: Krzysztof, I meant features from STL such as Algorithms, etc. I understand Generics are available in FX2.0. Are the iterators as rich as those in STL?
A: Yes they are. Check out https://msdn.microsoft.com/library/en- us/dnvs05/html/stl-netprimer.asp for more details.

Krzysztof Cwalina (Expert):
Q: Krzysztof: I tend to agree on the tradeoffs, however how much faster are we talking about? I originally started developing it in the better performing design, however later on I realized the headache this posed. ThanksA: It's hard to tell how much faster for something so fast in the first place. Basically once you get to a point when you count processor cycles, you need to measure the particular design alternatives. There is some guidance on micro benchmarks for common .NET operations (search MSDN for Jan Gray) but it should only be used to give you an idea, not to make decisions. For this you just have to measure.

Krzysztof Cwalina (Expert):
Q: Capitalization Styles - All letters in the identifier are capitalized. Use this convention only for identifiers that consist of two or fewer letters. What if you use something like GUI... it breaks the guidelines, but you normally see if as GUI... should
A: GUI should be capitalized as "Gui". Take a look at the System.Xml namesapce. XML is cased "Xml"!

Joe Duffy [MS] (Expert):
Q: I am reading a binary file which has for example bit mapped flags in ushort, currently I have the flag name value pairs in enum with flags attribute like enum myFlags : ushort { .. } can I compare value ReadUInt16 gives with myFlags without casting? how?
A: I am pretty sure that if you do a cast for your enum type, the C# compiler is smart enough to understand that this is typesafe. As such, I don't believe it does any type of casting or coercion at runtime.

Joe Duffy [MS] (Expert):
Q: Thanks Joe, that looks excellent
A: No problem. The author, Stann, has a blog too, where he has discussed this a couple times. I believe they have more articles lined up.

Brad Abrams [MSFT] (Expert):
Q: Regarding ref/out, it's my understanding out actually "clears" the parameter upon entry to a method (and subsequently requires an assignment prior to returning from the method). Is this correct or are there other issues under the covers?
A: Well, as I say in the talk, out is really a C# compiler feature, not a runtime feature. But C# does NOT prevents from you from assigning to an out parameter before the method call but it does forces you to assign a value to it in the method call. This will compile, int j = 10; Foo(out j); But this, gives an error, I must be assigned to. static void Foo(out int i) { }

Brad Abrams [MSFT] (Expert):
Q: Brad, marking classes serializable causes a performance hit I'm assuming, you mentioned you shouldn't mark it that way unless, are there any other reasons?
A: It is less that there is a perf hit and more a versioning and security issues...

Brad Abrams [MSFT] (Expert):
Q: We touched on this is in the naming conventions chat and I know it's a bit off-topic here, but can we expect the XML naming guidelines anytime soon?
A: I did ask about that, but we don't even have anything internally... Sorry about that...

Krzysztof Cwalina (Expert):
Q: We work in a world with a lot of 3 and 4 letter acronyms, yet FxCop and the documentation state you should only all-caps 2 or fewer letters? What's the thinking behind this?
A: This is just a convention with no reason other than we needed to have some rules so there is consistency. Now, I can give you some history behing the guideline. Intially we wanted a very simple rule that says that all acronyms are cased the say way (first letter upper case and then lower case). There was some push back from people saying that "Io" (I/O) is not acteptable.

Joe Duffy [MS] (Expert):
Q: No my question was not about inner classes in general. I was trying to understand the difference btwn static inner class and instance inner class. Java has the 2 kinds. .NET just has nested classes (same as java's "static" inner classes).
A: Right, so the difference boils down to: our classes are really just "nested" classes--i.e. static inner classes. They provide the lexical scoping benefits, but have no particular relationship to an actual *instance* of the enclosing type. So, a regular inner class can actually access the fields of an outer class with the assumption that an instance has been created. Our nested classes need to access a reference to an instance explicitly, but still have intimite accessibility with instances.

frankred [MS] (Moderator):
Q: I have downloaded a sample application from windowsforms.net and when i opened it it told me i could not because it was written in visual Basic .net 2005 so MSDN told me to install .net 2.0 and it should open. I still received the same error. at this point i uninstalled .net 2.0 because i needed the drive space. the next time i talked to MSDN they told me if i delete the exe and the pdb file i would be able to open this project in vb .net 2003. is this true or false?
A: Can you point me to the sample in question??

Joe Duffy [MS] (Expert):
Q: Joe can you explain where in this code does it have the information to use the default value when no value is provided for the [opt] param? I see .param [2] = int32(0x00000000) but how does it know to do it conditionally? And also does CLR also require op .method public instance void Foo(int32 x, [opt] int32 y) cil managed { .param [2] = int32(0x00000000) // Code size 1 (0x1) .maxstack 8 IL_0000: ret }
A: Yeah, so the magic is at the callsite. If you make a call to Foo(10), say, the VB compiler magically turns the calling code into Foo(10, 0). The metadata is the extent of the "runtime support". There's no conditional branching at runtime, it's all at compile time.

Brad Abrams [MSFT] (Expert):
Q: We work in a world with a lot of 3 and 4 letter acronyms, yet FxCop and the documentation state you should only all-caps 2 or fewer letters? What's the thinking behind this?
A: Good framework design is all about usability - you want to the developer to be able to intuitively know what your framework does. If you use a lot of acronyms then there is more to parse and understand. So rather than some archaic abbreviation we prefer using descriptive terms that explain really what the method does.

Brad Abrams [MSFT] (Expert):
Q: Can't you do the first draft Brad? You don't seem to be doing much else lately! ;)
A: Ha! I was going to ask *you* the same thing... :D

frankred [MS] (Moderator):
Q: Can I have the e-mail address for the person that kept pushing for edit-and-continue in C#? I'd like to buy them a beer!
A: Try https://blogs.msdn.com /scottno/

Joe Duffy [MS] (Expert):
Q: Can you point out a white paper detailing the differences in multithreading between .NET F and CF please?
A: CF doesn't support things like async delegates, nor does it support some of the thread control functionality. https://samples.gotdotnet.com/quickstart/CompactFramework/doc/controlinvoker.aspx has a few details.

frankred [MS] (Moderator):
We're almost out of time, so get your last question(s) in!

Krzysztof Cwalina (Expert):
Q: Do you see the inclusion of Generics ever becoming the troubled child of c# like variant ypes did in vb 5.0???
A: I think Generics as a language feature are great! I have written lots of code using Generics and I started to get the same feeling like like in the early days of .NET when programming become fun again :-). What I agree with you about is that we have to be very very careful about is how we use them in the Framework libraries. There is certainly a way to abuse Generics.

Joe Duffy [MS] (Expert):
Q: Joe, Thanks for inner class explaination. I was wondering if this was discussed and had any reasons for not supporting the instance inner classes?
A: Unfortunately, I don't know why we didn't support them. To be honest, I used to be primarily a Java guy, and they've always been a point of confusion. My best guess is that the C# language designers wanted to avoid confusing syntax, and I think this falls into that category.

Brad Abrams [MSFT] (Expert):
Q: So, what is the reason that C# executable files are Slower than Delphi and VC executables in First load (time to Double Click to appearing Forms ) ?
A: Well, I don’t know about the perf comparisons, but I do believe we have some challenges with working-set and therefore startup time for managed applications. This is particularly important for client apps.. For V1.1 what I can suggest is that you check out NGen and give that a try, in many cases that works. For 2.0 we are working heavily on this issue and have made a number of improvements that you should notice.

Krzysztof Cwalina (Expert):
Q: Is there some good reason why all the BeginRead etc async take a state as the last parameter, after all if I have instance of Stream, the callback gets called within the instance and I just dont see why pass any other states around?
A: Wow. It's been an hour already. I have to run to the next meeting. Thanks for all who joined and chated with us. See/Hear you all next time.

frankred [MS] (Moderator):
Q: Thanks Frank, I'm already subscribed to his blog. His debug visualiser posts are very interesting
A: Indeed! :-)

Joe Duffy [MS] (Expert):
Q: Is there some good reason why all the BeginRead etc async take a state as the last parameter, after all if I have instance of Stream, the callback gets called within the instance and I just dont see why pass any other states around?
A: You actually need the state most of the time for e.g. shared byte arrays so you can access the contents of the read. In the case where you have no need to pass additional state, you can supply null and it will work just fine.

frankred [MS] (Moderator):
Q: frankred [MS] (Moderator): yes give me a second
A: Sure thing. Take your time.

Brad [MS] (Expert):
Q: I can include the Microsoft.VisualBasic namespace in my c# app and gain access to the financial calculations in VB, will I be able to do the same thing to gain access to the My function in vb.net 2.0?
A: Yes -- it is all IL... you can access the library, just not the IDE features of My...

frankred [MS] (Moderator):
It looks like we're about out of time. I hope everyone had a good time and got answers to all of their questions. If you have more questions please visit the CLR team blogs https://msdn.microsoft.com/netframework/community/blogs/default.aspx section on the .NET Framework developer center. Please join us again next Wednesday for the next chat in the Designing .NET Class Libraries series https://msdn.microsoft.com/netframework/programming/classlibraries/ .

Joe Duffy [MS] (Expert):
Q: Joe can you answer my CLR qstn regarding opt params? Is there a limitation to where in the param list the opt params can appear?
A: The VB compiler does require this. Otherwise, it doesn't know when to start using defaults... E.g. consider with a function F that has integer params: a, b[opt], c. If somebody calls F(0, 1) how would you know whether 1 was for b or c? You could guess (as in this case, it'd be a syntax error to assume b), but for longer param lists it gets even more problematic.

Brad [MS] (Expert):
Well, thanks for coming, if you are in Dallas tomorrow night come check out my talk at the Dallas user’s group meeting…https://blogs.msdn.com/brada/archive/2005/01/28/362910.aspx

Joe Duffy [MS] (Expert):
Outta time already! Looking forward to chatting again next week. Take care... joe

frankred [MS] (Moderator):

Q: This question is for the moderator. Are there any chats available on Longhorn and its pillars? Specifically Avalon. Sorry not very relevant to this chat.
A: Not yet, but as we get closed to beta, absolutely. Watch this space: https://msdn2.microsoft.com/en-us/ms123402.aspx

frankred [MS] (Moderator):
Q: Thanks to all of you for your time. It was very interesting
A: Thank you!

frankred [MS] (Moderator):
Q: Thanks guys...
A: Thank you!

Brad [MS] (Expert):
Q: brad, why don't you swing up here to Oklahoma City?
A: Next time ;-)

frankred [MS] (Moderator):
Q: good bye
A: Good bye.

Brad [MS] (Expert):
Q: Thanks guys...
A: Thanks for comming!

Brad [MS] (Expert):
Q: Thank u brad for ur answers ;)
A: No problem, thanks for comming

frankred [MS] (Moderator):
Q: Bye Bye All ;)
A: Good Bye

frankred [MS] (Moderator):
Q: Thank you for putting these product specific chats on they are a great way to learn and I enjoy them alot.
A: We're glad developers are finding them useful.

frankred [MS] (Moderator):

Q: I love you CLR guys, just wanted you to know that. You make my life so much easier than it used to be. Now I can get twice as much work done but make the same amount of money.
A: We love you too, man! ;-)

Top of page

다음을 통해 공유

Designing .NET Class Libraries: Member Types (February 09, 2005)

추가 리소스