Quote: Original post by hpjchobbes
When would a programmer need to use the LOCK statement in a program?

Quote: Original post by hpjchobbes

When dealing with a class that inherits from a base class, the document states: " Inheritance means that a class implicitly contains all members of its base class, except for the constructors of the base class". In the example, they show a Point3D class that inherits from a Point class. The Point3D's constructor inherits from the Point constructor. Does the inherited constructor ever get run? In the example, do X and Y not get values since the Point3D constructor didn't specify?

public class Point3D: Point{    public int z;    public Point3D(int x, int y, int z)        : Point(x, y)                    // <-----    {        this.z = z;    }}

class A{    A()          { ... }    A(int x)     { ... }    A(string s)  { ... }}class B : A{    B()                           { ... } // construction order: A(), B()    B(int x) : base(x.ToString()) { ... } // order: A(string), B(int)}class C : B{    C() : base(5)     { ... }  // order : A(string), B(int), C()    C(string s)       { ... }  // order : A(), B(), C(string)}

• one implicit default constructor taking 0 arguments and initializing x and y to 0


• one taking 2 integer arguments

Quote: Original post by hpjchobbes
Last, I'm not sure I understand what "Metadata" is, other than the document states that it contains symbolic information. What does this mean?

Quote:
.NET metadata, in the Microsoft .NET framework, refers to code that describes .NET CIL (Common Intermediate Language) code. A .NET language compiler will generate the metadata and store this in the assembly containing the CIL. Metadata describes all classes and class members that are defined in the assembly, and the classes and class members that the current assembly will call from another assembly. The metadata for a method contains the complete description of the method, including the class (and the assembly that contains the class), the return type and all of the method parameters. When the CLR executes CIL it will check to make sure that the metadata of the called method is the same as the metadata that is stored in the calling method. This ensures that a method can only be called with exactly the right number of parameters and exactly the right parameter types.

Quote: Original post by hpjchobbes
On a similar topic to class inheritance, what's the difference between inheriting a function vs. overriding the function? It would seem that if you inherit then the base function would still get called, but I'm not sure.

Quote:
When a type inherits from a base class, all members of the base class, except instance constructors, destructors and static constructors, become members of the derived type.

// Only relevant members are shownclass Rectangle{    public float Width { get { ... } }    public float Height { get { ... } }    public virtual float Circumference    {        get { return Width * 2 + Height * 2; }    }    public virtual float Area    {        get { return Width * Height; }    }}// A square is a rectangle with Width == Heightclass Square : Rectangle{   public float Side { get { return Width; } }   public override float Circumference   {        get { return Side * 4; }   }}

Quote: An implicit conversion exists from a class type to any of its base class types. Therefore, a variable of a class type can reference an instance of that class or an instance of any derived class. For example, given the previous class declarations, a variable of type Point can reference either a Point or a Point3D:
Point a = new Point(10, 20);
Point b = new Point3D(10, 20, 30);

Quote: Original post by Ezbez
I have a question when answering question 1. Is it correct to say that object-oriented programming is a type of component-oriented programming? It seems to me that OOP is a type of COP because OOP helps you create "self-contained and self-describing packages of functionality".

Quote: C# is an object-oriented language, but C# further includes support for component-oriented programming. Contemporary software design increasingly relies on software components in the form of self-contained and self-describing packages of functionality. Key to such components is that they present a programming model with properties, methods, and events; they have attributes that provide declarative information about the component; and they incorporate their own documentation. C# provides language constructs to directly support these concepts, making C# a very natural language in which to create and use software components.

Quote: Original post by finky45

It seems to me it's just a lot of fancy talk for "we facilitated OOP a little more" but decided to give it a different name. Someone tell me why I'm wrong?

Quote: Original post by finky45

Quote: An implicit conversion exists from a class type to any of its base class types. Therefore, a variable of a class type can reference an instance of that class or an instance of any derived class. For example, given the previous class declarations, a variable of type Point can reference either a Point or a Point3D:
Point a = new Point(10, 20);
Point b = new Point3D(10, 20, 30);

Does this mean I can access the derived class' member functions if I cast it as a "Point"? i.e "b.setZ = 1337;"