Essential Books
Essential C# Keywords  Suggest an edit

abstract

A class marked with the keyword abstract cannot be instantiated.

A class must be marked as abstract if it contains abstract members or if it inherits abstract members that it doesn’t implement. A class may be marked as abstract even if no abstract members are involved.

Abstract classes are usually used as base classes when some part of the implementation needs to be specified by another component.

abstract class Animal 
{
    string Name { get; set; }
    public abstract void MakeSound();
}

public class Cat : Animal 
{
    public override void MakeSound()
    {
        Console.WriteLine("Meov meow");
    }
}

public class Dog : Animal 
{   
    public override void MakeSound()
    {
        Console.WriteLine("Bark bark");
    }
}

Animal cat = new Cat();       // Allowed due to Cat deriving from Animal
cat.MakeSound();              // will print out "Meov meow"

Animal dog = new Dog();       // Allowed due to Dog deriving from Animal
dog.MakeSound();              // will print out "Bark bark"

Animal animal = new Animal(); // Not allowed due to being an abstract class

A method, property, or event marked with the keyword abstract indicates that the implementation for that member is expected to be provided in a subclass. As mentioned above, abstract members can only appear in abstract classes.

abstract class Animal 
    {
       public abstract string Name { get; set; }
    }
    
    public class Cat : Animal 
    {
        public override string Name { get; set; }
    }
    
    public class Dog : Animal 
    {
        public override string Name { get; set; }
    }
Keywords/
as
goto
volatile
checked unchecked
virtual override new
stackalloc
break
const
for
async await
abstract
is
default
fixed
sealed
typeof
readonly
this
dynamic
foreach
try catch finally throw
namespace
void
ref out
float double decimal
char
params
base
operator
string
null
return
while
continue
using
ulong
uint
unsafe
int
var
lock
true false
internal
where
extern
switch
when
struct
static
if if...else if... else if
do
partial
unchecked
bool
interface
long
sizeof
in
enum
ushort
delegate
implicit
sbyte
event
Table Of Contents
1 Getting Started With C#
2 Literals
3 Operators
4 Conditional Statements
5 Equality Operator
6 Equals and GetHashCode
7 Null-Coalescing Operator
8 Null-Conditional Operators
9 nameof Operator
10 Verbatim String
11 Common String Operations
12 String Format
13 String Concatenate
14 String Manipulation
15 String Interpolation
16 String Escape Sequences
17 StringBuilder
18 Regex
19 DateTime
20 Arrays
21 On Algorithm for circular rotation of an array
22 Enum
23 Tuples
24 Overview of C# collections
25 GUID
26 BigInteger
27 Collection Initializers
28 Looping
29 Iterators
30 IEnumerable
31 Value type vs Reference type
32 Built-in Types
33 Aliases of built-in types
34 Anonymous types
35 Dynamic type
36 Type Conversion
37 Casting
38 Nullable types
39 Constructors and Finalizers
40 Access Modifiers
41 Interfaces
42 Static Classes
43 Singleton Implementation
44 Dependency Injection
45 Partial class and methods
46 Object Initializers
47 Methods
48 Extension Methods
49 Named Arguments
50 Named And Optional Arguments
51 Data Annotation
52 Keywords
53 Recursion
54 Naming Conventions
55 XML Documentation Comments
56 Comments and regions
57 Inheritance
58 Generics
59 Using Statement
60 Using Directive
61 IDisposable interface
62 Reflection
63 IQueryable interface
64 LINQ to Objects
65 LINQ Queries
66 LINQ to XML
67 Parallel LINQ PLINQ
68 XmlDocument
69 XDocument
70 C# 7.0 Features
71 C# 6.0 Features
72 C# 5.0 Features
73 C# 4.0 Features
74 C# 3.0 Features
75 Exception Handling
76 NullReferenceException
77 Handling FormatException
78 Read and Understand Stack trackes
79 Diagnostics
80 Overflow
81 JSON handling
82 Using json.net
83 Lambda Expressions
84 Lambda expressions
85 Generic Lambda Query Builder
86 Properties
87 Initializing Properties
88 INotifyPropertyChanged interface
89 Events
90 Expression Trees
91 Overload Resolution
92 Preprocessor directives
93 Structs
94 Attributes
95 Delegates
96 File and Stream IO
97 Networking
98 Performing HTTP requests
99 Reading and writing .zip files
100 FileSystemWatcher
101 Asynchronous Socket
102 Action Filters
103 Polymorphism
104 Immutability
105 Indexer
106 Checked and Unchecked
107 Stream
108 Timers
109 Stopwatches
110 Threading
111 Async/Await, BackgroundWorker, Task and Thread examples
112 Async Await
113 Synchronization Context in Async/Await
114 BackgroundWorker
115 Task Parallel Library
116 Making a variable thread safe
117 Lock Statement
118 Yield Keyword
119 Task Parallel Library TPL Dataflow Constructs
120 Functional Programming
121 Func delegates
122 Function with multiple return values
123 Binary Serialization
124 ICloneable
125 IComparable
126 Accessing Databases
127 Using SQLite
128 Caching
129 Code Contracts
130 Code Contracts and Assertions
131 Structural Design Patterns
132 Creational Design Patterns
133 Implementing Decorating Design Pattern
134 Implementing Flyweight Design Pattern
135 System.Management.Automation
136 Pointers
137 Pointers and Unsafe Code
138 Simulating C Unions with C# Structs
139 Reactive Extensions Rx
140 AsseblyInfo.cs examples
141 Creating Console Application
142 CLSCompliantAttribute
143 ObservableCollection<T>
144 Hash Functions
145 Generating Random Numbers
146 Cryptography
147 Unsafe Code in .NET
148 C# Script
149 Runtime Compile
150 Interoperability
151 .NET Compiler Platform Roslyn
152 Creating Own MessageBox in Windows Form Application
153 Including Font Resources
154 Garbage Collector
155 Windows Communication Foundation
156 Contributors
  ↑ ↓ to navigate     ↵ to select     Esc to close