Clarify that abstract classes can contain implemented methods alongside abstract members

docs/csharp/language-reference/keywords/abstract.md

@@ -12,8 +12,23 @@ ms.assetid: b0797770-c1f3-4b4d-9441-b9122602a6bb
 # abstract (C# Reference)
 
 The `abstract` modifier indicates that the thing being modified has a missing or incomplete implementation. The abstract modifier can be used with classes, methods, properties, indexers, and events. Use the `abstract` modifier in a class declaration to indicate that a class is intended only to be a base class of other classes, not instantiated on its own. Members marked as abstract must be implemented by non-abstract classes that derive from the abstract class.
+
+Abstract classes can contain both abstract members (which have no implementation and must be overridden in derived classes) and fully implemented members (such as regular methods, properties, and constructors). This allows abstract classes to provide common functionality while still requiring derived classes to implement specific abstract members.
 
-## Example 1
+## Example 1 - Abstract class with mixed members
+
+The following example demonstrates an abstract class that contains both implemented methods and abstract members:
+
+:::code language="csharp" source="snippets/shared/Abstract.cs" id="snippet1":::
+
+In this example, the `Vehicle` abstract class provides:
+
+- **Implemented members**: `GetInfo()` method, `StartEngine()` method, and constructor - these provide common functionality for all vehicles
+- **Abstract members**: `Move()` method and `MaxSpeed` property - these must be implemented by each specific vehicle type
+
+This design allows the abstract class to provide shared functionality while ensuring that derived classes implement vehicle-specific behavior.
+
+## Example 2
 
  In this example, the class `Square` must provide an implementation of `GetArea` because it derives from `Shape`:  
 
@@ -25,6 +40,8 @@ The `abstract` modifier indicates that the thing being modified has a missing or
 
 - An abstract class may contain abstract methods and accessors.  
 
+- An abstract class can also contain implemented methods, properties, fields, and other members that provide functionality to derived classes.
+
 - It is not possible to modify an abstract class with the [sealed](./sealed.md) modifier because the two modifiers have opposite meanings. The `sealed` modifier prevents a class from being inherited and the `abstract` modifier requires a class to be inherited.  
 
 - A non-abstract class derived from an abstract class must include actual implementations of all inherited abstract methods and accessors.  
@@ -61,7 +78,7 @@ The `abstract` modifier indicates that the thing being modified has a missing or
 
 [!code-csharp[csrefKeywordsModifiers#2](~/samples/snippets/csharp/VS_Snippets_VBCSharp/csrefKeywordsModifiers/CS/csrefKeywordsModifiers.cs#2)]
 
-## Example 2
+## Example 3
 
  In this example, the class `DerivedClass` is derived from an abstract class `BaseClass`. The abstract class contains an abstract method, `AbstractMethod`, and two abstract properties, `X` and `Y`.  
 
@@ -77,7 +94,7 @@ You will get an error saying that the compiler cannot create an instance of the
 
 Nonetheless, it is possible to use an abstract class constructor, as in the  example below
 
-## Example 3
+## Example 4
 
 [!code-csharp[csrefKeywordsModifiers#27](~/samples/snippets/csharp/VS_Snippets_VBCSharp/csrefKeywordsModifiers/CS/csrefKeywordsModifiers.cs#27)]
 

docs/csharp/language-reference/keywords/snippets/shared/Abstract.cs

@@ -0,0 +1,90 @@
+//<snippet1>
+namespace LanguageKeywords;
+
+public abstract class Vehicle
+{
+    protected string _brand;
+
+    // Constructor - implemented method in abstract class
+    public Vehicle(string brand) => _brand = brand;
+
+    // Implemented method - provides functionality that all vehicles share
+    public string GetInfo() => $"This is a {_brand} vehicle.";
+
+    // Another implemented method
+    public virtual void StartEngine() => Console.WriteLine($"{_brand} engine is starting...");
+
+    // Abstract method - must be implemented by derived classes
+    public abstract void Move();
+
+    // Abstract property - must be implemented by derived classes  
+    public abstract int MaxSpeed { get; }
+}
+
+public class Car : Vehicle
+{
+    public Car(string brand) : base(brand) { }
+
+    // Implementation of abstract method
+    public override void Move() => Console.WriteLine($"{_brand} car is driving on the road.");
+
+    // Implementation of abstract property
+    public override int MaxSpeed => 200;
+}
+
+public class Boat : Vehicle
+{
+    public Boat(string brand) : base(brand) { }
+
+    // Implementation of abstract method
+    public override void Move() => Console.WriteLine($"{_brand} boat is sailing on the water.");
+
+    // Implementation of abstract property
+    public override int MaxSpeed => 50;
+}
+
+public class AbstractExample
+{
+    public static void Examples()
+    {
+        // Cannot instantiate abstract class: Vehicle v = new Vehicle("Generic"); // Error!
+
+        Car car = new Car("Toyota");
+        Boat boat = new Boat("Yamaha");
+
+        // Using implemented methods from abstract class
+        Console.WriteLine(car.GetInfo());
+        car.StartEngine();
+
+        // Using abstract methods implemented in derived class
+        car.Move();
+        Console.WriteLine($"Max speed: {car.MaxSpeed} km/h");
+
+        Console.WriteLine();
+
+        Console.WriteLine(boat.GetInfo());
+        boat.StartEngine();
+        boat.Move();
+        Console.WriteLine($"Max speed: {boat.MaxSpeed} km/h");
+    }
+}
+
+class Program
+{
+    static void Main()
+    {
+        AbstractExample.Examples();
+    }
+}
+/* Output:
+This is a Toyota vehicle.
+Toyota engine is starting...
+Toyota car is driving on the road.
+Max speed: 200 km/h
+
+This is a Yamaha vehicle.
+Yamaha engine is starting...
+Yamaha boat is sailing on the water.
+Max speed: 50 km/h
+*/
+//</snippet1>