Why do I get an error instantiating an abstract class?

Question

I downloaded a NuGet package called Process.NET, and I try to use the Read() method from the IMemory interface in my main() function. I implemented it as in the GIT tutorial, but I am unable to create an instance of ProcessMemory like this:

ProcessMemory memory = new ProcessMemory();

I get this error:

"Unable to create instance of the abstract class or interface 'ProcessMemory'. "

I found some threads about that, but nothing could help me yet. Here is my Code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Process.NET.Memory;
using Process.NET.Native.Types;

namespace MemoryHacker
{
    class Program
    {
        static void Main(string[] args)
        {

            ProcessMemory memory = new ProcessMemory();

        }
    }

    //Class with Read() function
    public abstract class ProcessMemory : IMemory
    {
        protected readonly SafeMemoryHandle Handle;

        protected ProcessMemory(SafeMemoryHandle handle)
        {
            Handle = handle;
        }

        public abstract byte[] Read(IntPtr intPtr, int length);

        public string Read(IntPtr intPtr, Encoding encoding, int maxLength)
        {
            var buffer = Read(intPtr, maxLength);
            var ret = encoding.GetString(buffer);
            if (ret.IndexOf('\0') != -1)
                ret = ret.Remove(ret.IndexOf('\0'));
            return ret;
        }

        public abstract T Read<T>(IntPtr intPtr);

        public T[] Read<T>(IntPtr intPtr, int length)
        {
            var buffer = new T[length];
            for (var i = 0; i < buffer.Length; i++)
                buffer[i] = Read<T>(intPtr);
            return buffer;
        }

        public abstract int Write(IntPtr intPtr, byte[] bytesToWrite);

        public void Write(IntPtr intPtr, string stringToWrite, Encoding encoding)
        {
            if (stringToWrite[stringToWrite.Length - 1] != '\0')
                stringToWrite += '\0';
            var bytes = encoding.GetBytes(stringToWrite);
            Write(intPtr, bytes);
        }


        public void Write<T>(IntPtr intPtr, T[] values)
        {
            foreach (var value in values)
                Write(intPtr, value);
        }

        public abstract void Write<T>(IntPtr intPtr, T value);
    }

}

EDIT: Okay, the thing with the instantiating is clear now. But I am still getting an error:

"No argument was specified that corresponds to the formal handle parameter of ProcessMemory.ProcessMemory (SafeMemoryHandle)."

any ideas, while watching the code above?

EDIT2: All you need to solve this problem is said in the answers below. Just a little hint, if you are using Visual Studio, then rightclick the new class, and click on implement. It writes a lot of stuff for ya!

Answer 1

I'm not familiar with the package, and it is not clear to me what you are trying to achieve, so I don't really know how I can help you, but I can tell you this:

An abstract class is not supposed to be instantiated.

you'll either have to remove the abstract keyword, or make your own class, that implements the abstract class like this:

public class MyProcessMemory : ProcessMemory
{
    public override byte[] Read(IntPtr intPtr, int length)
    {
        throw new NotImplementedException();
    }

    public override T Read<T>(IntPtr intPtr)
    {
        throw new NotImplementedException();
    }

    public override int Write(IntPtr intPtr, byte[] bytesToWrite)
    {
        throw new NotImplementedException();
    }

    public override void Write<T>(IntPtr intPtr, T value)
    {
        throw new NotImplementedException();
    }
}

In either case you'll have to come up with your own implementation of the abstract functions. Hope this helps

Answer 2

You can not use abstract classes directly. You can use those when creating new class that derives from those

Answer 3

You cannot instantiate an abstract class. The purpose of an abstract class is to provide a common interface for deriving classes. It's not explicitly necessary for an abstract class to provide an implementation for any method (notice the lack of body for the methods marked abstract) because it's expected that the child classes provide the bulk of the implementation. Read the documentation to see which child class is best suited for your needs and instantiate that.

Answer 4

You can not instantiate an abstract class directly, you need to create another class that implements it and provides a complete implementation by completing any methods marked as abstract in the base class. In your case this is:

byte[] Read(IntPtr intPtr, int length)

T Read<T>(IntPtr intPtr)

int Write(IntPtr intPtr, byte[] bytesToWrite)

void Write<T>(IntPtr intPtr, T value)

The following link may aid you in understanding more https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/abstract. Relating to classes it states in that:

The abstract modifier indicates that the thing being modified has a missing or incomplete implementation.

and

Members marked as abstract, or included in an abstract class, must be implemented by classes that derive from the abstract class.