Inheritance

Classes are inherited in C# the same way that interfaces are implemented in C#. 
    public class TestParaPrism : TestParallelogram {
        private int elevation;
        public TestParaPrism(int left, int top, int basewidth, int baseheight, int offset, bool ishorizontal, int tall) {
            if (ishorizontal) { // The top and bottom sides of the parallelogram are flat, left and right sides are sloped
                if (offset > 0) { // Upper left corner to the right of lower left corner.
                    vertices = new Point[] {new Point(left+offset, top), new Point(left+basewidth+offset, top), 
                                            new Point(left+basewidth, top+baseheight), new Point(left, top+baseheight)};
                    // Make the vertices.
                } else { // Upper left corner farther left than lower left corner.
                    vertices = new Point[] {new Point(left, top), new Point(left+basewidth, top), 
                                            new Point(left-offset+basewidth, top+baseheight), new Point(left-offset, top+baseheight)};
                } // End of offset's if block.
            } else { // The left and right sides of the parallelogram are flat, top and bottom sides are sloped.
                if (offset > 0) { // Upper left corner is below the upper right corner.
                    vertices = new Point[] {new Point(left, top+offset), new Point(left+basewidth, top),
                                            new Point(left+basewidth,top+baseheight), new Point(left, top+baseheight+offset)};
                } else { // Upper left corner is above the upper right corner.
                    vertices = new Point[] {new Point(left, top), new Point(left+basewidth, top-offset),
                                            new Point(left+basewidth,top+baseheight-offset), new Point(left, top+baseheight)};
                } // End of offset's if block.
            } // End of horizontal check if block.
            elevation = tall;
        } // End of TestParaPrism constructor.

        public int Volume() {
            return base.Area() * elevation;
        } // End of volume function.
    }
Usage:
        private void btn14_Click(object sender, EventArgs e) {
            TestParaPrism woodbeam = new TestParaPrism(0, 0, 50, 50, 10, true, 20);
            MessageBox.Show(woodbeam.Area().ToString()); // Underlying parallelogram's area is 2500.
            MessageBox.Show(woodbeam.Volume().ToString()); // Volume of prism is 50000.
            woodbeam = null; //Protip: Annul object references.
        } // End of btn 14's click procedure.
You'll notice that there doesn't seem to be any line that is equivalent to calling MyBase.New in VB.NET. I'm not entirely sure how it works, but I think C# actually does this for us automatically, rather than VB.NET saying that the first line should be MyBase.New. There also doesn't seem to be a way to call the constructor of the base either. Regardless, the code above works. You'll notice in the Volume function, the equivalent to MyBase is simply base. Let's just hope that you don't actually need a variable named base in your class.
The functionality of inherited classes is essentially the same in VB.NET and C#, as it should be. Notice that .Area, a function of a parallelogram, can be safely called from the para-prism.
So, let's override the Inflate subroutine so that we also increase the elevation of our prism with addheight. Recall, in VB.NET, the four keywords that controlled overriding rules were named obviously: Overridable, Overrides, MustOverride,and NotOverridable. In C#, you'll have to correlate with virtual, override, abstract, and sealed. 
        virtual public void Inflate(int addwidth, int addheight) {
            vertices[1].Offset(addwidth, 0);
            // Offset is a member of the Point structure which basically moves a point.
            vertices[2].Offset(addwidth, addheight);
            vertices[3].Offset(0, addheight);
        } // End of inflate subroutine.

        public override void Inflate(int addwidth, int addheight) {
            base.Inflate(addwidth, addheight);  // Very nice.
            elevation += addheight; // Let's also change the elevation.
        } // End of Inflate override
Making Inflate a virtual public void means that we can now override the Inflate subroutine in the TestParaPrism class. Note that we cannot specify an extra parameter because the Inflate method is available to both classes and both classes will only accept two integers. 
        public void Inflate(int addwidth, int addheight) {
            vertices[1].Offset(addwidth, 0);
            // Offset is a member of the Point structure which basically moves a point.
            vertices[2].Offset(addwidth, addheight);
            vertices[3].Offset(0, addheight);
        } // End of inflate subroutine.

        new public void Inflate(int addwidth, int addheight) {
            base.Inflate(addwidth, addheight);  // Very nice.
            elevation += addheight; // Let's also change the elevation.
        } // End of the new Inflate subroutine
The above two boxes show how you would shadow the Inflate subroutine. Though VB.NET uses a different keyword to shadow elements, namely, Shadows, C# simply reuses an old keyword to achieve the same effort, although it does effectively provide a new Inflate subroutine to use. 
        public void Inflate(int addwidth, int addheight, int addelevation) {
            base.Inflate(addwidth, addheight);  // Very nice.
            elevation += addelevation; // Let's also change the elevation.
        } // End of Inflate subroutine.
If you declare Inflate to have three parameters, the declaration no longer matches the version of Inflate in Parallelogram. Therefore, this method does not override or shadow anything - it simply serves as another overload to Inflate that is only accessible from the ParaPrism.

Events, Delegates, and EventHandlers

To create a button on your form at runtime: 
        private void btn15_Click(object sender, EventArgs e) {
            Button btn16 = new Button();
            btn16.Location = new Point(181, 362);
            btn16.Visible = true;
            btn16.Click += new EventHandler(randomsub);
            this.Controls.Add(btn16);
        } // End of btn 15's click procedure.

        private void randomsub(object sender, EventArgs e) {
            MessageBox.Show("Run-time event handler successful.");
        } // End of randomsub
I find it funny that C# actually uses the += operator to add the eventhandler to the Click event. Funny, but it works. Not much extra work is required: just specify what type of EventHandler (delegate) you want. 
        public delegate void InflationEventHandler(object sender, EventArgs e, int test);
        // Allows the class to call a subroutine that accepts an object and an EventArgs.
        public event InflationEventHandler Inflated; // Allows the class to raise the objname_Inflated event.
You can also have your class raise events as well. The int test is just a random number to pass through the delegate to show that the random number below (159) does make it back to the event handler subroutine for this class. 
        public void Inflate(int addwidth, int addheight, int addelevation) {
            base.Inflate(addwidth, addheight);  // Very nice.
            elevation += addelevation; // Let's also change the elevation.
            Inflated(this, null, 159); // Raises the Inflated event.
        } // End of Inflate subroutine.
To raise the event, call the event just like you would a subroutine, but pass in the arguments requested, because you have to remember that the event was declared as a type of InflationEventHandler, and the InflationEventHandler wants an object, an EventArgs, and an integer. 
        private void woodbeam_Inflated(object sender, EventArgs e, int randomnumber) {
            MessageBox.Show(randomnumber.ToString());
        } // End of woodbeam's inflated procedure.
Declare a subroutine in the old class that takes the correct series of arguments, and then 'add' the eventhandler. 
        private void btn14_Click(object sender, EventArgs e) {
            TestParaPrism woodbeam = new TestParaPrism(0, 0, 50, 50, 10, true, 20);
            woodbeam.Inflated += new TestParaPrism.InflationEventHandler(woodbeam_Inflated);
            // When woodbeam is inflated, the woodbeam_Inflated event procedure will run, using information collected from the InflationEventHandler.
            woodbeam.Inflate(10, 10, 15);
            MessageBox.Show(woodbeam.Area().ToString()); // Underlying parallelogram's area is 2500.
            MessageBox.Show(woodbeam.Volume().ToString()); // Volume of prism is 50000.
            woodbeam = null; //Protip: Annul object references.
        }// End of btn 14's click procedure.
So, you should see the random number 159 pop-up before the area and volume pop-up.