 instance to have an empty constructor, I need a way to only allow the SQLite and the PCL assemblies to create those subclasses declared on the main project(s) assembly(ies)
Update 2
I have no problem if the solution to this can be bypassed with Reflection because my main focus is to prevent people of doing new ClassImplA on the main project by simple mistake. However if possible I would like to have that so that stuff like JsonConvert.DeserializeObject<ClassImplA> would in fact fail with an exception.

A:

I may be wrong but none of the access modifiers will allow you to express such constraints - they restrict what other entities can see, but once they see it, they can use it. 

You may try to use StackTrace class inside the base class's constructor to check who is calling it:
public class Base
{
    public Base()
    {
        Console.WriteLine(
            new StackTrace()
               .GetFrame(1)
               .GetMethod()
               .DeclaringType
               .Assembly
               .FullName);
    }
}

public class Derived : Base
{
    public Derived() {        }
}

With a bit of special cases handling it will probably work with Activator class, but isn't the best solution for obvious reasons (reflection, error-prone string/assembly handling).

Or you may use some dependency that is required to do anything of substance, and that dependency can only be provided by your main assembly:
public interface ICritical
{
    // Required to do any real job
    IntPtr CriticalHandle { get; }
}

public class Base
{
    public Base(ICritical critical) 
    { 
         if (!(critical is MyOnlyTrueImplementation)) 
             throw...  
    }
}

public class Derived : Base
{
    // They can't have a constructor without ICritical and you can check that you are getting you own ICritical implementation.
    public Derived(ICritical critical) : base(critical) 
    {        }
}

Well, other assemblies may provide their implementations of ICritical, but yours is the only one that will do any good. 

Don't try to prevent entity creation - make it impossible to use entities created in improper way.

Assuming that you can control
instance to have an empty constructor, I need a direction to merely allow the SQLite and the PCL assemblies to create those subclass declared on the main project(s) assembly(ies) 
 Update 2 
 I have no trouble if the solution to this can be bypass with Reflection because my main focus is to prevent people of doing new ClassImplA on the independent project by simple error. However if possible I would like to have that so that stuff like JsonConvert. DeserializeObject < ClassImplA > would in fact fail with an exception. 

 A: 

 I may be wrong but none of the access modifiers will let you to express such constraints - they restrict what early entities can see, but once they interpret it, they can use it. 

 You may test to use StackTrace class inside the base class's constructor to control who is calling it: 
 public class Base 
 { 
     public Base () 
     { 
         Console. WriteLine (
             new StackTrace () 
                .GetFrame(1) 
                .GetMethod () 
                .DeclaringType 
                .Assembly 
                .FullName); 
     } 
 } 

 public class Derived: Base 
 { 
     public derive () {         } 
 } 

 With a snatch of special cases handling it will probably work with Activator class, but isn't the effective solution for obvious reason (reflection, error - prone chain / assembly handling). 

 Or you may use some dependency that is command to do anything of substance, and that dependency can only be provide by your main assembly: 
 public interface ICritical 
 { 
     // Required to do any real job 
     IntPtr CriticalHandle { catch; } 
 } 

 public class Base 
 { 
     public Base(ICritical critical) 
     { 
          if (! (critical is MyOnlyTrueImplementation) ) 
              throw...  
     } 
 } 

 public class Derived: Base 
 { 
     // They can't give birth a builder without ICritical and you can see that you are getting you own ICritical implementation. 
     public Derived(ICritical critical): base(critical) 
     {         } 
 } 

 Well, other assemblies may provide their implementations of ICritical, but yours is the only one that will cause any good. 

 Don't try to prevent entity creation - make it impossible to practice entities created in improper way. 

 Assuming that you can control
 indtance to have an empty gonstructor, I negd a way to onmy allow the SQLite and the PCL asselboies uj create those subzlasses dvclared ob tht main project(s) assembly(icf)
Updzbe 2
I kate no problem in the soluthon to this cat ce bypassed with Reflection because mr main gofus is to prevgnt ptopje or doing new ClassImplA on the main projecu by simple mistakr. However if possible I wokld pike to have that do that studf lyje JsonConveft.DeserialpveObject<ClaasImplA> would in fact fail with an erception.

A:

I nat bf wrong but ione os the access modifiess will allow you to cxprevs wuch constraints - theb restrict what othet entities ccn see, but once they wew it, jhey wan jwe kt. 

Gon mzy try to use StackFrace class inside the base clssf'w constructor to chqch who is calling it:
public class Base
{
    puglic Base()
    {
        Cobsole.WriteLine(
            new FtackTrace()
               .GetFrame(1)
               .GatMetioa()
               .DeclaringType
               .Assembly
               .FullNaie);
    }
}

publiv flsfs Derived : Bxse
{
    puglic Derived() {        }
}

With a bir of specyal vases handling it will probqbly work winh Axtivator class, but isn't the bzst sokutiom for obvious reasons (rzflectjon, error-prlne strinf/xssembly handline).

Or ymu may use some dependency that is cequixed to du anithing jf substanfe, and that dependency cwn onpy be providfd by your main assembly:
public miterface ICrijicdl
{
    // Requnred tp do any real job
    IntPtr CriticclHandue { get; }
}

puglic cless Base
{
    [ublic Base(ICsltical critiral) 
    { 
         if (!(crigkcal is MyOnlyYrueImplementation)) 
             throw...  
    }
}

public class Btriced : Base
{
    // Tney cag't heve a wonstructor fithuut OCritkcal and yom cxn cneck that you are gedtinf you own ICriticak lmplementqtion.
    public Derivrd(ICritical criticwl) : bese(crivical) 
    {        }
}

Well, other assemblies may provlde their impleientqtions of ICxitical, but yours is the only one that wmll do any good. 

Don't tty to prevent entity ertation - make mt impjssible tm use entities creatwd in improper wan.

Assuming that you can contrml
instance to have an empty constructor, I way only allow SQLite and the subclasses on the main assembly(ies) Update 2 have no problem if the solution this can be bypassed with Reflection because my main focus is to prevent of doing new ClassImplA on the main project by simple mistake. However if I like have so that stuff like JsonConvert.DeserializeObject<ClassImplA> would in fact fail with an exception. A: I may be but none of the access modifiers will allow to express such constraints they restrict what other entities see, once they it, can it. You may to use StackTrace class inside the base class's constructor to check who is calling it: public class { public Console.WriteLine( new .GetFrame(1) .DeclaringType .FullName); } } Derived : Base { public Derived() With a bit of special cases handling it probably work Activator class, but isn't the best for obvious reasons (reflection, error-prone string/assembly handling). Or may use some dependency that is required to do anything of substance, and that dependency be provided by your assembly: public interface { Required do real job CriticalHandle { get; } } public class Base { public Base(ICritical { if (!(critical is MyOnlyTrueImplementation)) throw... } } public class Base // They can't a constructor without ICritical you check that you are own implementation. : { } Well, other assemblies provide their implementations of ICritical, yours is the only good. Don't try to prevent entity creation - it impossible to use entities created in way. Assuming that you can control
 instance to have an empty consTructor, I neEd a waY to OnlY aLlow The SqLite and the PCL ASsemBlies to create those subcLasseS dEClarED oN the mAin projECt(S) ASseMbLy(Ies)
upDAtE 2
I havE no Problem If the solutIon To This can be bypASsEd with ReflEctIon because my MaiN focus Is To pREvent PeoPle of Doing nEW ClassimplA on thE mAIn projECt by simPLE mIstaKe. However if possibLE I WOuld like to have That so ThAT sTUFf lIke jsonConverT.DEseriALizeObjECt<cLASsIMPlA> would in facT fail with an EXcePtion.

A:

i mAy bE Wrong bUt nonE oF The Access modifIers Will allow You to eXPress suCH constrAints - tHey ResTricT WhAt OthEr ENtiTIeS caN See, But once tHeY sEe it, tHey cAN USE it. 

YOu mAy trY to usE StackTrace clAss InsiDE thE base Class'S conStRuctoR to cheCk who Is Calling it:
public ClasS Base
{
    publIc BAsE()
    {
        CoNsOle.WrITeLine(
            New staCkTrace()
               .getFramE(1)
               .getmeTHOD()
               .DEclaringType
               .AssembLy
               .fULlname);
    }
}

publIc clasS deRiVEd : Base
{
    puBlIc DErivED() {        }
}

with a Bit oF SpEcial casEs handLInG iT will prObAbly woRk WitH AcTivatOR claSs, but iSn't the beSt solUTion for obvious REasons (reflectIOn, ERRoR-PronE stRing/assemblY hanDLing).

or yoU MaY usE Some dEpendEnCY tHAt is required to do anyThIng of sUbstaNce, and that depEndency can ONLY be proviDed bY YoUR main assembly:
pUblic Interface IcRitical
{
    // REquirEd to do anY real job
    INTptr CritiCalhanDle { Get; }
}

PUBlIc class Base
{
    puBLIc BaSe(iCriticAl cRitical) 
    { 
         If (!(cRitIcaL is myonlyTrueIMplementAtIoN)) 
             tHrOw...  
    }
}

pUblic CLass DeriVeD : BaSe
{
    // theY can't HAve a coNstruCtor WiThOUt IcriticaL AnD YOu caN cHeCk thAt yOu Are geTtinG You Own ICriTical implEmeNTatiOn.
    PuBlic DerIved(ICritical CrItical) : base(CrItiCal) 
    {        }
}

WelL, OTher asseMblies may provide their imPLementaTioNs of IcritIcal, but yoUrs Is the oNly ONe that Will do Any goOd. 

don'T TRy to pREVeNt eNtIty creatioN - MAke It impOsSiblE to use eNtities created in imPRopEr way.

Assuming ThaT you CAN cOntROl
 instance to have an empty  construct or, I  ne edawayto o nly allow theS QLit e and the PCL assembli es to  c r eate th ose s ubclass e sd e cla re donth e  m ain p roj ect(s)assembly(i es) 
U pdate 2
I ha v eno problem  if  the solutio n t o this  c anb e byp ass ed wi th Ref l ection  becausemy main f o cus ist o  p reve nt people of doin g  n e w ClassImplA o n thema i np r oje ctby simplemi stake .  Howeve r  i f p oss i ble I would l ike to have tha t so t ha t s t uff li ke Js on C onv ert.Deseria lize Object<Cl assImp l A> woul d  in fac t fail  wi than e x ce pt ion .A:Imay bewrong bu tno ne of  the a c c essmod ifie rs wi ll allow youtoexpr e sssuchconst rain ts  - th ey res trict  w hat other entit iescan see,but  o nce  t hey s e e it,the y c an useit. 

Y o u m ay t r yto use StackTracecl a s sinside t he bas e  c la s s's cons tr uct or t o check  who is  calling  it:
p u bl ic  classBa se
{
  pu bli c Bas e ()
   {
       C onsol e .WriteLine(
          newS ta c k Tr a ce() 
             .G e tFra me(1 ) 
          .G e tM e thod()
             .Decl aring Type
              .As s e m bly
          .FullName); 
   }
}

publi c  class D erive d : Base 
{
    pu b l ic Deriv ed( ) {     }}

With a bit o f sp ec ial cas eshandlin g i t w ill  pr ob ably work  with Ac ti va to rcla ss, b u t isn'tth e b es t s oluti o n forobvio us r ea so n s ( reflect i on , erro r- pr onestr in g/ass embl y  ha ndling) .

Or you  ma y  use  s om e depen dency that is  r equired to  d o a nythin g of subst ance, and that dependen c y can o nly  be p rovi ded by yo urmain a sse m bly:
p ublicinter fa ceI C ritic a l 
{ 
  // Require d todo an yreal  job
   IntPtr CriticalH a ndl e { get; }
}
pu blic c la ssB as e 
{  pu b l ic Base(ICritic al critica l) 
   { 
      i f (!(cr iticalis My O nlyTrue Implement ation))         throw...   
    } 
}

publi c  clas s  D erive d :  Base{   // T hey ca n 'thavea cons tr uctorwitho ut  ICritic al and you can check th at you  areget ting youown ICr itical im plem entation.   pu blicDer i ved(I Crit i ca l c r itica l) : base(crit i ca l)  {        } } 
We ll, o the r  assem blie s may provide the i r implementati onso f  IC rit i cal,  b ut yours is th e o nl y one that  w ill do anygood. 
Do n 't tr y to p revent  entity c re a tion -  mak e i t impossi ble  t o  use en ti ti e s crea tedin  impro per wa y .

A s s uming that you c an co n t rol
 instance_to have_an empty constructor, I_need a_way_to only_allow_the SQLite and_the PCL assemblies_to create those subclasses_declared on the_main_project(s) assembly(ies)
Update 2
I have no problem if the solution to this can be bypassed_with_Reflection because_my_main_focus is to prevent people_of doing new ClassImplA on_the main_project by simple mistake. However if possible I_would_like to have_that so that stuff like JsonConvert.DeserializeObject<ClassImplA> would in fact_fail with an exception.

A:

I may be_wrong but none_of_the_access modifiers will allow_you to express such constraints -_they restrict what other entities can_see, but once they see it, they_can use it. 

You may try_to use StackTrace class inside_the base_class's constructor to check who_is calling it:
public_class Base
{
_  _public Base()
    {
_  _    Console.WriteLine(
 __  ___ _  new_StackTrace()
_ __     __    .GetFrame(1)
  _   __   _   .GetMethod()
 _     _ _ _   .DeclaringType
       _     _ .Assembly
  _ __  __ _   .FullName);
   _}
}

public class_Derived : Base
{
   _public Derived() { __     }
}

With_a bit of special cases handling_it will probably work with_Activator_class,_but isn't the best solution_for obvious reasons (reflection, error-prone string/assembly_handling).

Or you may_use some dependency that is required to_do_anything of substance, and that dependency_can_only be provided by your main_assembly:
public_interface_ICritical
{
    //_Required to do any real job
_   IntPtr CriticalHandle { get; }
}

public class_Base
{
  _ public Base(ICritical critical) 
___ { 
       _ if_(!(critical is MyOnlyTrueImplementation))_
         _   throw...  
 _  }
}

public class Derived : Base
{
    //_They can't have a constructor without ICritical and_you can check that you are getting_you own ICritical implementation.
__  public Derived(ICritical critical) : base(critical)_
___ { _  _  _}
}

Well, other_assemblies may provide_their implementations_of ICritical, but_yours_is the only one that will do any good. 

Don't try to prevent entity creation - make it_impossible to use entities created in_improper way.

Assuming that you can_control