[ToolboxItem(true)]
public class CustomDateEdit : DateEdit
{
    static CustomDateEdit()
    {
        RepositoryItemCustomDateEdit.RegisterCustomDateEdit();
    }

    public CustomDateEdit()
    {
    }

    [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
    public new RepositoryItemCustomDateEdit Properties => base.Properties as RepositoryItemCustomDateEdit;

    public override string EditorTypeName => RepositoryItemCustomDateEdit.CustomEditName;

    protected override PopupBaseForm CreatePopupForm()
    {
        return new CustomDateEditPopupForm(this);
    }
}

[UserRepositoryItem("RegisterCustomDateEdit")]
public class RepositoryItemCustomDateEdit : RepositoryItemDateEdit
{
    static RepositoryItemCustomDateEdit()
    {
        RegisterCustomDateEdit();
    }

    public const string CustomEditName = "CustomDateEdit";

    public RepositoryItemCustomDateEdit()
    {
    }

    public override string EditorTypeName => CustomEditName;

    public static void RegisterCustomDateEdit()
    {
        Image img = null;
        EditorRegistrationInfo.Default.Editors.Add(new EditorClassInfo(CustomEditName, typeof(CustomDateEdit), typeof(RepositoryItemCustomDateEdit), typeof(CustomDateEditViewInfo), new CustomDateEditPainter(), true, img));
    }

    public override void Assign(RepositoryItem item)
    {
        BeginUpdate();
        try
        {
            base.Assign(item);
            RepositoryItemCustomDateEdit source = item as RepositoryItemCustomDateEdit;
            if (source == null) return;
            //
        }
        finally
        {
            EndUpdate();
        }
    }
}

public EditorClassInfo(
    string name, // Specifies the editor's name.
    Type editorType, // Specifies the type of the editor class.
    Type repositoryType, // Specifies the type of the custom repository item class.
    Type viewInfoType, // Specifies the type of the editor's ViewInfo class.
    BaseEditPainter painter,// An instance of the editor's Painter class.
    bool designTimeVisible, // Specifies whether or not the custom editor 
                            // will be visible at design time within container controls 
                            // (for instance, when creating an in-place editor
                            // within Grid Control or XtraBars).
    Image image, // Specifies the image that will be displayed along 
                            // with the editor's name within container controls.
    Type accessibleType // Specifies the type of the object 
                            // that provides accessibility information.
);

public class RepositoryItemCustomDateEdit : RepositoryItemDateEdit
{
    // ...
    public static void RegisterCustomDateEdit()
    {
        Image img = null;
        EditorRegistrationInfo.Default.Editors.Add(new EditorClassInfo(CustomEditName, typeof(CustomDateEdit), typeof(RepositoryItemCustomDateEdit), typeof(CustomDateEditViewInfo), new CustomDateEditPainter(), true, img));
    }
}

using System.Drawing;
using System.Reflection;
using System.ComponentModel;
using System.Windows.Forms;
using System.Reflection;
using DevExpress.XtraEditors;
using DevExpress.XtraEditors.Repository;
using DevExpress.XtraEditors.Registrator;
using DevExpress.XtraEditors.Drawing;
using DevExpress.XtraEditors.ViewInfo;
using DevExpress.Accessibility;

namespace DevExpress.CustomEditors {

    //The attribute that points to the registration method
    [UserRepositoryItem("RegisterCustomEdit")]
    public class RepositoryItemCustomEdit : RepositoryItemTextEdit {

        //The static constructor that calls the registration method
        static RepositoryItemCustomEdit() { RegisterCustomEdit(); }

        //Initialize new properties
        public RepositoryItemCustomEdit() {            
            useDefaultMode = true;
        }

        //The unique name for the custom editor
        public const string CustomEditName = "CustomEdit";

        //Return the unique name
        public override string EditorTypeName { get { return CustomEditName; } }

        //Register the editor
        public static void RegisterCustomEdit() {
            //Icon representing the editor within a container editor's Designer
            Image img = null;
            try {
                img = (Bitmap)Bitmap.FromStream(Assembly.GetExecutingAssembly().
                  GetManifestResourceStream("DevExpress.CustomEditors.CustomEdit.bmp"));
            }
            catch {
            }
            EditorRegistrationInfo.Default.Editors.Add(new EditorClassInfo(CustomEditName, 
              typeof(CustomEdit), typeof(RepositoryItemCustomEdit), 
              typeof(TextEditViewInfo), new TextEditPainter(), true, img, typeof(TextEditAccessible)));
        }

        //A custom property
        private bool useDefaultMode;

        public bool UseDefaultMode {
            get { return useDefaultMode; }
            set {
                if(useDefaultMode != value) {
                    useDefaultMode = value;                        
                    OnPropertiesChanged();
                }
            }
        }

        //Override the Assign method
        public override void Assign(RepositoryItem item) {
            BeginUpdate(); 
            try {
                base.Assign(item);
                RepositoryItemCustomEdit source = item as RepositoryItemCustomEdit;
                if(source == null) return;
                useDefaultMode = source.UseDefaultMode;
            }
            finally {
                EndUpdate();
            }
        }
    }

    [ToolboxItem(true)]
    public class CustomEdit : TextEdit {

        //The static constructor that calls the registration method
        static CustomEdit() { RepositoryItemCustomEdit.RegisterCustomEdit(); }

        //Initialize the new instance
        public CustomEdit() {
            //...
        }

        //Return the unique name
        public override string EditorTypeName { get { return 
            RepositoryItemCustomEdit.CustomEditName; } }

        //Override the Properties property
        //Simply type-cast the object to the custom repository item type
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public new RepositoryItemCustomEdit Properties {
            get { return base.Properties as RepositoryItemCustomEdit; }
        }

    }
}

Imports System.Reflection
Imports System.Drawing
Imports System.ComponentModel
Imports System.Windows.Forms
Imports System.Reflection
Imports DevExpress.XtraEditors
Imports DevExpress.XtraEditors.Repository
Imports DevExpress.XtraEditors.Registrator
Imports DevExpress.XtraEditors.Drawing
Imports DevExpress.XtraEditors.ViewInfo
Imports DevExpress.Accessibility

'The attribute that points to the registration method
<UserRepositoryItem("RegisterCustomEdit")> _
Public Class RepositoryItemCustomEdit
    Inherits RepositoryItemTextEdit

    'The static constructor that calls the registration method
    Shared Sub New()
        RegisterCustomEdit()
    End Sub

    'Initialize new properties
    Public Sub New()
        _useDefaultMode = True
    End Sub

    'The unique name for the custom editor
    Public Const CustomEditName As String = "CustomEdit"

    'Return the unique name
    Public Overrides ReadOnly Property EditorTypeName() As String
        Get
            Return CustomEditName
        End Get
    End Property

    'Register the editor
    Public Shared Sub RegisterCustomEdit()
        'Icon representing the editor within a container editor's Designer
        Dim img As Image = Nothing
        Try
            img = Bitmap.FromStream( _
Assembly.GetExecutingAssembly().GetManifestResourceStream( _
"DevExpress.CustomEditors.CustomEdit.bmp"))
        Catch
        End Try
        EditorRegistrationInfo.Default.Editors.Add(New EditorClassInfo(CustomEditName, _
          GetType(CustomEdit), GetType(RepositoryItemCustomEdit), _
          GetType(TextEditViewInfo), New TextEditPainter, True, img, GetType(TextEditAccessible)))
    End Sub

    'A custom property
    Private _useDefaultMode As Boolean

    Public Property UseDefaultMode() As Boolean
        Get
            Return _useDefaultMode
        End Get
        Set(ByVal Value As Boolean)
            If (Not _useDefaultMode = Value) Then
                _useDefaultMode = Value
                OnPropertiesChanged()
            End If
        End Set
    End Property

    'Override the Assign method
    Public Overrides Sub Assign(ByVal item As RepositoryItem)
        BeginUpdate()
        Try
            MyBase.Assign(item)
            Dim source As RepositoryItemCustomEdit = TryCast(item, RepositoryItemCustomEdit)
            If source Is Nothing Then Return
            _useDefaultMode = source.UseDefaultMode
        Finally
            EndUpdate()
        End Try
    End Sub
End Class

<ToolboxItem(True)> _
Public Class CustomEdit
    Inherits TextEdit

    'The static constructor that calls the registration method
    Shared Sub New()
        RepositoryItemCustomEdit.RegisterCustomEdit()
    End Sub

    'Initialize the new instance
    Public Sub New()
        '...
    End Sub

    'Return the unique name
    Public Overrides ReadOnly Property EditorTypeName() As String
        Get
            Return RepositoryItemCustomEdit.CustomEditName
        End Get
    End Property

    'Override the Properties property
    'Simply type-cast the object to the custom repository item type
    <DesignerSerializationVisibility(DesignerSerializationVisibility.Content)> _
    Public Shadows ReadOnly Property Properties() As RepositoryItemCustomEdit
        Get
            Return TryCast(MyBase.Properties, RepositoryItemCustomEdit)
        End Get
    End Property

End Class