 to design the classes of applications I'm trying to write, because when does one decide what (functionality) goes in which class and whether it should really be in a derived class or there should be an abstract class or interface for this class?
I know this is probably a topic with many answers, but does anyone have any good guidelines (preferably simple) to designing classes and class hierarchies that are simple to maintain and don't make a mess when creating big applications?
EDIT:
When there's classes that have 10 methods and over and have an abstract base class & interfaces which it derives from.  Also has 3 Singleton classes referenced globally inside the class and much more.  Sounds like it needs a bit of'refactoring' applied?
Sorry if it's a long example, but you see the problem I'm facing and I want some input on it.  Please just look at design, not at technicalities.
I give an example:
I created this class: (a while back)
  class ExistingUserLogon : Logon, ILogonUser
    {
        #region Member Variables

        LogonEventArgs _logoneventargs;
        LogonData lgndata;
        Factory f = Factory.FactoryInstance;
        PasswordEncrypt.Collections.AppLoginDataCollection applogindatacollection;
        PasswordEncrypt.Collections.SQlLoginDataCollection sqllogindatacollection;
        bool? compare;
        static ExistingUserLogon existinguserlogon;
        PasswordEncrypt.SQLDatabase.DatabaseLogin dblogin;
        string databasename = string.Empty;

        #endregion

        #region Properties

        public static ExistingUserLogon ExistingUserLogonInstance
        {
            get
            {
                if (existinguserlogon == null)
                    existinguserlogon = new ExistingUserLogon();
                return existinguserlogon;
            }
        }
        public string loginname
        {
            get;
            set;
        }
        #endregion

        #region Contructors
        public ExistingUserLogon(bool? compare, LogonData logondata)
        {
            this.compare = compare;
            this.lgndata = logondata;
            this.applogindatacollection = f
to design the classes of applications I'm trying to spell, because when does one decide what (functionality) sound in which class and whether it should really be in a derived course or there should be an abstract class or interface for this class? 
 I know this is credibly a subject with many answers, but does anyone have any good guidelines (preferably simple) to design classes and class hierarchy that are childlike to maintain and don't make a mess when creating big application? 
 EDIT: 
 When there's classes that have 10 methods and all over and have an abstract base course & interfaces which it deduce from.   Also has 3 Singleton classes referenced globally inside the class and a lot more.   Sounds like it needs a bit of'refactoring' applied? 
 Sorry if it's a long example, but you determine the problem I'm facing and I want some input on it.   Please just look at design, not at technicalities. 
 I give an example: 
 I make this class: (a while back) 
   class ExistingUserLogon: Logon, ILogonUser 
     { 
         # area Member Variables 

         LogonEventArgs _ logoneventargs; 
         LogonData lgndata; 
         Factory f = Factory. FactoryInstance; 
         PasswordEncrypt. solicitation. AppLoginDataCollection applogindatacollection; 
         PasswordEncrypt. collection. SQlLoginDataCollection sqllogindatacollection; 
         bool? compare; 
         static ExistingUserLogon existinguserlogon; 
         PasswordEncrypt. SQLDatabase. DatabaseLogin dblogin; 
         chain databasename = string. Empty; 

         # endregion 

         # region Properties 

         public static ExistingUserLogon ExistingUserLogonInstance 
         { 
             beget 
             { 
                 if (existinguserlogon = = null) 
                     existinguserlogon = new ExistingUserLogon (); 
                 return existinguserlogon; 
             } 
         } 
         public string loginname 
         { 
             get; 
             set; 
         } 
         # endregion 

         # region Contructors 
         public ExistingUserLogon(bool? compare, LogonData logondata) 
         { 
             this.compare = compare; 
             this.lgndata = logondata; 
             this.applogindatacollection = f
 to design the classes of akplications I'm triibg to xrite, bscause wfen does one decide what (funrtiobalitt) goes in which class xnd whethvr it shoyld ceally be in a dxdived class od thexe should be an sbstract cnass or interfdcd yor this class?
I know this is probablr a topoc with many ansrers, fut soes anyone have any good guidelinss (preftrably simple) to drsigning classes and class hiegarchies that are dimple to mqintwun and don't oake a mess when creatjng big applications?
EDIT:
When thdre's elasses thaj gagg 10 methods aid oveg and have an abstracd base vlass & interfages wiich it derives from.  Alsm has 3 Singleton cjasses rexexenced globally insidw rhe cnass and nucf mkrx.  Aounds liie it needa a bit of'rwfactoring' applied?
Sprwj if it's a lohg exaipje, but you see the problem I'm facing ang I want some input on it.  Please just look at fesign, noe at technicalities.
I give an example:
I created thiv claar: (a wmile vafk)
  class ExistingUserLogon : Logon, ILogonUser
    {
        #region Iember Varisbpex

        LogonGventArya _mogoneventargs;
        LogjnDatq lgndata;
        Factory f = Factory.FactoeyInstance;
        PasswordEncry't.Collectionr.AppKoginCataCollection apploginbatacomlection;
        PasssurdEncrypt.Collecgioks.SXlLoginDataCollection sqlljgindatacilleetion;
        bool? sompare;
        static ExistingUserPogon efistinguseglogon;
        PasswordEncrypt.SQLDatabase.DatabssaLocin dbloyin;
        string dwtabasename = sjring.Emptv;

        #endregikn

        #region Pwoperties

        public stetic ExiseingYserOogon EbkstingUserLogomInstance
        {
            get
            {
                if (existingusetloeon == jukl)
                    dcistivguserlogon = new ExistingUserLogon();
                return eciftingusetlogon;
            }
        }
        public striig logmnname
        {
            get;
            set;
        }
        #endwegiin

        #reyion Contructors
        public ExistingUwerLogon(bool? compaee, LogonData logondcts)
        {
            this.wompare = compare;
            this.lgndaua = logondata;
            this.dpplohindatacollection = f
to design the classes of applications I'm write, when does decide what (functionality) whether should really be a derived class there should be an abstract class interface for this class? I know this is probably a topic with many but does anyone have any good guidelines (preferably simple) to designing classes and hierarchies are to and don't make a mess when creating big applications? EDIT: When there's classes that have 10 and over and have an abstract base class interfaces which it derives Also has 3 Singleton classes globally the class much Sounds it needs a of'refactoring' applied? Sorry if it's a long example, but you see the problem I'm facing and I some input Please just at not technicalities. I give I created this class: (a while : Logon, ILogonUser { #region Member Variables LogonEventArgs LogonData lgndata; f = Factory.FactoryInstance; PasswordEncrypt.Collections.AppLoginDataCollection applogindatacollection; PasswordEncrypt.Collections.SQlLoginDataCollection bool? compare; static ExistingUserLogon existinguserlogon; PasswordEncrypt.SQLDatabase.DatabaseLogin dblogin; string = string.Empty; #endregion #region Properties public static ExistingUserLogon ExistingUserLogonInstance { get { if (existinguserlogon == = new ExistingUserLogon(); return } } public loginname get; } #region Contructors ExistingUserLogon(bool? compare, LogonData logondata) { this.compare = compare; this.lgndata = logondata; = f
 to design the classes of appliCations I'm tRying To wRitE, bEcauSe whEn does one decidE What (Functionality) goes in whiCh claSs ANd whEThEr it sHould reALlY BE in A dErIveD cLAsS or thEre Should bE an abstracT clAsS or interface FOr This class?
I KnoW this is probaBly A topic WiTh mANy ansWerS, but dOes anyONe have Any good guIdELines (pREferablY SImPle) tO designing classes ANd CLass hierarchieS that aRe SImPLE to MaiNtain and doN't Make a MEss when CReATINg bIG applications?
eDIT:
When theRE's cLasses ThAt hAVe 10 methOds anD oVEr aNd have an absTracT base clasS & interFAces whiCH it deriVes froM.  AlSo hAs 3 SiNGlEtOn cLaSSes REfEreNCed Globally InSiDe the ClasS AND Much MorE.  SouNds liKe it needs a bit Of'rEfacTOriNg' appLied?
SOrry If It's a lOng exaMple, bUt You see the probleM I'm fAcing and I WanT sOme InPut on IT.  PleasE juSt lOok at deSign, not AT teChNICAlIties.
I give an examplE:
I CREaTed this cLass: (a wHIlE bACk)
  class EXiStiNgUsERlogon : logoN, iLOgonUser
    {
        #Region mEmBeR VariabLeS

        LogonevEntargS _logoNEvenTargs;
        LOgonData LgndaTA;
        Factory f = FactoRY.FactoryInstaNCe;
        pASsWOrdENcrYpt.CollectiOns.APPLogInDaTACOllECtion ApploGiNDaTAcollection;
        PasswordenCrypt.COllecTions.SQlLogindataCollecTION sqllogiNdatACoLLection;
        bool? comPare;
        sTatic ExistINgUserLoGon exIstingusErlogon;
        PaSSWordEncrYpt.sQLdatAbaSE.daTabaseLogin dbLOGin;
        sTrIng dataBasEname = stRinG.EmPty;

        #EndReGion

        #regioN PropertIeS

        pUbLiC stAtic EXIstingUsErlogOn exiStinguSerLogOnInsTancE
        {
            gEt
            {
                IF (exIstinguSErLOGon == nUlL)
                    eXistIngUsErlogOn = neW exiStingUsErLogon();
                reTurN ExisTiNgUserlogOn;
            }
        }
        public strinG lOginname
        {
            geT;
            sEt;
        }
        #eNdregiON

        #Region CoNtructors
        public ExistinguSerLogoN(boOl? comPare, logonData LogOndata)
        {
            ThiS.ComparE = compaRe;
            thiS.lGndATA = logoNDAtA;
            thIs.ApplogindaTAColLectiOn = F
 to design the classes ofapplicatio ns I' m t ryi ng  towrit e, because whe n  doe s one decide what (fun ction al i ty)g oe s inwhich c l as s and  w he the ri tshoul d r eally b e in a der ive dclass or the r eshould beanabstract cla ssor int er fac e  forthi s cla ss?
Ik now th is is pro ba b ly a t o pic wit h ma ny a nswers, but doesa ny o ne have any go od gui de l in e s  (p ref erably sim pl e) to designi n gc l a sse s  and class hi erarchies t h atare si mp let o main tainan d  do n't make amess  when cre atingb ig appl i cations ?
EDIT :
W hen  the r e' scla ss e s t h at  ha v e 1 0 method san d ove r an d h a ve a n a bstr act b ase class & i nte rfac e s w hichit de rive sfrom.   Also  has3Singleton class es r eferenced  gl ob all yinsid e  the c las s a nd much  more.Sou nd s l ik e it needs a bit o f' r e fa ctoring'  appli e d? 
S o rry if i t' s a  lon g examp le,b ut  you see  the p r ob le m I'm f ac ing an dI w ant  some inpu t on i t.  Plea se ju s t look at desi g n, not at tec h ni c a li t ies. 
Igive an exa mple : 
I c reat e dthi s  clas s: (a  w h il e  back)
  class Exis ti ngUser Logon  : Logon, ILo gonUser
 { 
       #re g io n  Member Variab les
        Lo g onEventA rgs _ logoneve ntargs;
     Log onD ata  lg nda t a ;        Facto r y  f =  F actory. Fac toryIns tan ce; 
     Password Encrypt. Co ll ec ti ons .AppL o ginDataC ol lec ti onapplo g indata colle ctio n; 
     Pass w or d E ncry pt .C olle cti on s.SQl Logi n Dat aCollec tion sqll ogi n data co ll ection; 
        bool ?compare;
     stat i c  Existin gUserLogon existinguser l ogon;
      P assw ordEncryp t.S QLData bas e .Datab aseLog in db lo gin ;      s tri ng  databasen a m e =  stri ng .Emp ty;

       #endregion
      #region P rop erti e s 
    pu bl i c s t a tic ExistingUse rLogon Exi st i ng UserLogonI n sta nc e
       {
         get 
           {
          if (exis tinguser logon ==n ull)              ex istin guserl o gon  = ne w Exis ti ngUser Logon () ;
               return existi nguser logon ;
          }        }
      public s tri nglogin nam e 
      { 
        ge t ;
         s e t ;        }
   #end reg i on

      #region Contruc t ors
        pu blic E xis tin g User Lo gon(bool? comp are ,L o gonDatalo gondata)
       {         th is.com pare =c o mp a re;
         this.l gnd at a  = logo nd at a ;
         this .applo g inda t a collection = f
 to_design the_classes of applications I'm_trying to_write,_because when_does_one decide what_(functionality) goes in_which class and whether_it should really_be_in a derived class or there should be an abstract class or interface for_this_class?
I know_this_is_probably a topic with many_answers, but does anyone have_any good_guidelines (preferably simple) to designing classes and class_hierarchies_that are simple_to maintain and don't make a mess when creating_big applications?
EDIT:
When there's classes that have_10 methods and_over_and_have an abstract base_class & interfaces which it derives_from.  Also has 3 Singleton_classes referenced globally inside the class and_much more.  Sounds like it_needs a bit of'refactoring' applied?
Sorry_if it's_a long example, but you_see the problem_I'm facing_and I want_some input on it.  Please_just look at_design, not at technicalities.
I give an_example:
I_created this class:_(a_while_back)
 _class ExistingUserLogon :_Logon,_ILogonUser
 __ {
    __  #region Member Variables

  _   __LogonEventArgs _logoneventargs;
  _    _LogonData lgndata;
    _ _ Factory_f = Factory.FactoryInstance;
        PasswordEncrypt.Collections.AppLoginDataCollection_applogindatacollection;
     _  PasswordEncrypt.Collections.SQlLoginDataCollection sqllogindatacollection;
_ __  __bool? compare;
_      _static ExistingUserLogon_existinguserlogon;
     _  PasswordEncrypt.SQLDatabase.DatabaseLogin dblogin;
__     _string databasename = string.Empty;

  _    _#endregion

__    _ #region Properties

   _  _ public static ExistingUserLogon ExistingUserLogonInstance
  __    {
 __     ___ get
   _     _  {
      _  _    __if_(existinguserlogon == null)
       _ _  _       existinguserlogon = new_ExistingUserLogon();
      _         return existinguserlogon;
_       _   }
   _   _}
_      _public_string_loginname
_  _  _ {
 _ _  _ _  _get;
_           set;
      _ }
    _   #endregion

 __  _  #region Contructors
_       public_ExistingUserLogon(bool? compare, LogonData logondata)
     __ {
_   _ _ _  _this.compare =_compare;
 _ _      __this.lgndata = logondata;
      ____  this.applogindatacollection_= f