پیاده سازی اصول برنامه نویسی SOLID در زبان دارت و فریمورک فلاتر

اصول SOLID در برنامه نویسی فلاتر مجموعه‌ای از پنج اصل راهنما هستند که بر نحوه سازماندهی کلاس‌ها و روابط بین آن‌ها تمرکز دارند و هدفشان کاهش

معماری نرم افزار و الگوهای طراحی، راه‌حل‌های از پیش تعریف شده برای مسائل رایج در طراحی نرم‌افزار هستند که به صورت الگوهایی قابل استفاده مجدد ارائه می‌شوند.

این الگوها، تجربیات موفق در حل مسائل مشابه را به صورت مدون در اختیار توسعه‌دهندگان قرار می‌دهند و باعث افزایش سرعت توسعه و بهبود کیفیت نرم‌افزار می‌شوند.

درک و استفاده صحیح از این دو مفهوم، برای هر توسعه‌دهنده‌ای که به دنبال نوشتن کد تمیز، قابل نگهداری و مقیاس‌پذیر است، ضروری به نظر می‌رسد.

یکی از الگوهای طراحی اصول SOLID میباشد که در این مقاله به پیاده سازی آنها در فریمورک فلاتر و زبان برنامه نویسی دارت میپردازیم.

قواعد SOLID چیست؟

اصول SOLID و الگوهای طراحی، دو مفهوم بنیادین در مهندسی نرم‌افزار شیءگرا هستند که به توسعه‌دهندگان در ایجاد سیستم‌های قابل نگهداری، توسعه‌پذیر و مقاوم در برابر تغییرات کمک می‌کنند.

اصول SOLID، مجموعه‌ای از پنج اصل راهنما هستند که بر نحوه سازماندهی کلاس‌ها و روابط بین آن‌ها تمرکز دارند و هدفشان کاهش وابستگی‌ها، افزایش قابلیت استفاده مجدد و بهبود خوانایی کد است.

1. Single Responsibility Principle (SRP)

اصل تک‌مسئولیتی (Single Responsibility Principle یا SRP) یکی از اصول پایه‌ای برنامه‌نویسی شیءگرا در میان اصول SOLID است.

این اصل بیان می‌کند که یک کلاس باید تنها یک دلیل برای تغییر داشته باشد.

به بیان ساده‌تر، یک کلاس باید روی یک وظیفه خاص متمرکز باشد و از انجام کارهای زیاد و درهم‌وبرهم اجتناب کند.

این امر باعث بهبود سازمان‌دهی کد، قابلیت نگهداری و آزمون‌پذیری آن می‌شود.

بیایید یک سناریو در سیستم مدیریت بیمارستان را در نظر بگیریم. به طور سنتی، ممکن است یک کلاس به نام Patient داشته باشید که وظایف مختلفی را انجام می‌دهد، مانند:

  • ذخیره اطلاعات بیمار (نام، شناسه و غیره)
  • انجام فرآیندهای پزشکی
  • تولید صورتحساب
  • مدیریت قرارهای ملاقات

با پیروی از اصل SRP، این رویکرد مشکل‌ساز می‌شود، زیرا کلاس Patient دلایل متعددی برای تغییر دارد.

اگر نیاز به اضافه کردن یک قابلیت جدید مربوط به صورتحساب داشته باشید، مجبور خواهید بود کلاس Patient را تغییر دهید و این ممکن است بر بخش‌های دیگری که به مدیریت اطلاعات بیمار وابسته هستند، تأثیر بگذارد.

به جای این، با اعمال اصل تک‌مسئولیتی، بهتر است هر یک از این وظایف در کلاس‌های جداگانه قرار گیرند.

مثلاً یک کلاس برای مدیریت اطلاعات بیمار، یک کلاس برای انجام فرآیندهای پزشکی، یک کلاس برای تولید صورتحساب و یک کلاس برای مدیریت قرارهای ملاقات.

این کار باعث می‌شود کد شما تمیزتر، قابل درک‌تر و آسان‌تر برای نگهداری و توسعه باشد.

class Patient {
  final String name;
  final int id;
  final DateTime dateOfBirth;

  // Other attributes related to patient information

  Patient(this.name, this.id, this.dateOfBirth);
}

class MedicalProcedure {
  final String name;
  final DateTime date;
  final Patient patient;

  // Methods to perform or record medical procedures

  MedicalProcedure(this.name, this.date, this.patient);
}

class Billing {
  final double amount;
  final Patient patient;
  final List<MedicalProcedure> procedures;

  // Methods to calculate and manage bills

  Billing(this.amount, this.patient, this.procedures);
}

class Appointment {
  final DateTime dateTime;
  final Patient patient;
  final String doctorName;

  // Methods to manage appointments

  Appointment(this.dateTime, this.patient, this.doctorName);
}

این خیلی بهتره! با داشتن کلاس‌های جداگانه برای بیمار (Patient)، اقدام_پزشکی (MedicalProcedure)، صورتحساب (Billing) و نوبت (Appointment)، ما اصل SRP رو به خوبی رعایت کردیم. هر کلاس روی یه وظیفه مشخص تمرکز داره:

  • بیمار: فقط اطلاعات مربوط به بیمار رو ذخیره می‌کنه. (اسم، شماره پرونده، آدرس و غیره)
  • اقدام_پزشکی: نمایانگر یه اقدام پزشکی هست که روی بیمار انجام شده. (نوع اقدام، تاریخ، پزشک و غیره)
  • صورتحساب: مدیریت صورتحساب‌های مربوط به بیمار و اقدامات انجام شده رو بر عهده داره. (محاسبه هزینه، ثبت پرداخت و غیره)
  • نوبت: زمان‌بندی نوبت‌ها برای بیماران رو انجام میده. (تاریخ و ساعت نوبت، پزشک مربوطه و غیره)

این جداسازی مزایای زیادی داره:

  • تغییرات ایزوله: اگه لازم باشه تغییری در نحوه مدیریت صورتحساب‌ها ایجاد کنیم، فقط باید کلاس صورتحساب رو تغییر بدیم و نیازی به دستکاری کلاس‌های دیگه نیست. این باعث میشه ریسک ایجاد باگ در بخش‌های دیگه سیستم به شدت کاهش پیدا کنه.
  • خوانایی و نگهداری بهتر: کد خواناتر و قابل فهم‌تر میشه، چون هر کلاس وظیفه مشخص و محدودی داره. این امر نگهداری و دیباگ کردن کد رو هم آسون‌تر می‌کنه.
  • قابلیت استفاده مجدد: کلاس‌ها مستقل از هم هستن و می‌تونن در بخش‌های دیگه سیستم یا حتی در پروژه‌های دیگه هم مورد استفاده قرار بگیرن.
  • تست‌پذیری بهتر: تست کردن هر کلاس به صورت جداگانه بسیار ساده‌تره. می‌تونیم به راحتی برای هر کلاس تست‌های واحد (unit tests) بنویسیم و از صحت عملکرد اون مطمئن بشیم.

به طور خلاصه، این ساختار با رعایت اصل SRP، یه سیستم انعطاف‌پذیرتر، قابل نگهداری‌تر و تست‌پذیرتر رو به ما میده.

2. Open/Closed Principle (OCP)

اصل باز/بسته (Open/Closed Principle یا OCP) یکی از اصول مهم در برنامه‌نویسی شیءگراست که بر گسترش قابلیت‌ها بدون تغییر کد موجود تأکید داره.

به عبارت دیگه، یه کلاس باید برای توسعه باز باشه (یعنی بتونیم قابلیت‌های جدید بهش اضافه کنیم) اما برای تغییر بسته باشه (یعنی نیازی به تغییر کد اصلی کلاس نباشه).

نحوه اعمال این اصل در برنامه شما به این صورته:

شما یه ویجت پایه به اسم PatientDetails دارید که اطلاعات اصلی بیمار مثل نام، شماره پرونده و تاریخ تولد رو نمایش میده.

به طور سنتی، ممکنه منطق نمایش جزئیات بیشتر مثل تشخیص بیماری یا سابقه دارویی رو مستقیماً داخل این ویجت اضافه کنید.

اما این رویکرد اصل OCP رو نقض می‌کنه، چون اضافه کردن جزئیات جدید مستلزم تغییر PatientDetails هست. با بزرگتر شدن برنامه، این کار می‌تونه دست و پا گیر و مستعد خطا بشه.

راه حل با استفاده از OCP:

کلاس پایه انتزاعی (PatientDetail):

یه کلاس پایه انتزاعی به اسم PatientDetail با یه متد buildDetailWidget ایجاد می‌کنید که مسئول نمایش یه جزئیات خاصه.

abstract class PatientDetail {
  final String title;

  PatientDetail(this.title);

  Widget buildDetailWidget(BuildContext context, Patient patient);
}

این یعنی به جای اینکه همه چیز رو داخل یک ویجت فلاتر قرار دهیم، یک ساختار قابل توسعه ایجاد می‌کنیم.

حالا می‌تونیم جزئیات جدید رو بدون تغییر کد PatientDetails اضافه کنیم.

این کار با ایجاد کلاس‌های جدید که از PatientDetail ارث می‌برن و متد buildDetailWidget رو override می‌کنن، انجام میشه.

به عنوان مثال

کلاس‌های مشخصی مانند NameDetail، IdDetail، DateOfBirthDetail و غیره ایجاد کنید که از کلاس PatientDetail ارث‌بری می‌کنند.

هر زیرکلاس، متد buildDetailWidget را پیاده‌سازی می‌کند تا اطلاعات خاص خود را نمایش دهد.

class NameDetail extends PatientDetail {
  NameDetail() : super("Name");

  @override
  Widget buildDetailWidget(BuildContext context, Patient patient) {
    return Text(patient.name);
  }
}

مثال دیگر:

یه کلاس DiagnosisDetail ایجاد می‌کنید که از PatientDetail ارث می‌بره و متد buildDetailWidget رو طوری پیاده‌سازی می‌کنه که تشخیص بیماری رو نمایش بده.

یه کلاس دیگه به اسم MedicationHistoryDetail ایجاد می‌کنید که اون هم از PatientDetail ارث می‌بره و سابقه دارویی رو نمایش میده.

حالا ویجت PatientDetails می‌تونه لیستی از اشیاء PatientDetail رو بگیره و متد buildDetailWidget هر کدوم رو فراخوانی کنه تا جزئیات مربوطه نمایش داده بشه.

اینجوری برای اضافه کردن هر جزئیات جدید، فقط کافیه یه کلاس جدید ایجاد کنیم و نیازی به تغییر کد PatientDetails نیست. این دقیقاً همون چیزیه که OCP به دنبالشه: توسعه بدون تغییر.

ویجت PatientDetails

ویجت PatientDetails اکنون شامل یک لیست از اشیاء PatientDetail است.

این ویجت از طریق لیست تکرار می‌شود و از متد buildDetailWidget هر شیء جزئیات برای ساخت رابط کاربری استفاده می‌کند.

class PatientDetails extends StatelessWidget {
  final Patient patient;
  final List<PatientDetail> details;

  PatientDetails(this.patient, this.details);

  @override
  Widget build(BuildContext context) {
    return Column(
      children: details.map((detail) => detail.buildDetailWidget(context, patient)).toList(),
    );
  }
}

مزایای رویکرد OCP:

  1. گسترش آسان: اضافه کردن جزئیات جدید مانند تشخیص یا سوابق دارویی، تنها نیاز به ایجاد یک زیرکلاس جدید از PatientDetail با منطق ویجت خاص خود دارد. هیچ تغییری در PatientDetails لازم نیست.
  2. انعطاف‌پذیری: می‌توانید ترتیب نمایش جزئیات را با تنظیم ترتیب لیست جزئیات در PatientDetails کنترل کنید.
  3. قابلیت نگهداری: کد تمیزتر و قابل درک‌تر است، زیرا هر جزئیات یک ویجت اختصاصی دارد که مسئول نمایش آن است.

این یک مثال ساده‌شده است. در یک برنامه واقعی، ممکن است از یک راه‌حل مدیریت state (مانند Provider یا BLoC) برای مدیریت داده‌های بیمار و به‌روزرسانی پویای لیست جزئیات نمایش‌داده‌شده استفاده کنید.

3. Liskov Substitution Principle (LSP)

اصل جایگزینی لیسکوف (Liskov Substitution Principle یا LSP) یکی دیگر از اصول پایه‌ای SOLID است.

این اصل بیان می‌کند که زیرگونه‌ها (subtypes) باید بتوانند جایگزین گونه‌های پایه (base types) خود شوند بدون اینکه صحت برنامه را به خطر بیندازند.

به بیان ساده‌تر، اگر یک کلاس پایه (یا ویجت در فلاتر) و کلاس‌های مشتق‌شده (زیرکلاس‌ها یا ویجت‌های فرزند) داشته باشید، استفاده از یک کلاس مشتق‌شده در هر جایی که انتظار کلاس پایه را دارید، باید بدون ایجاد رفتار غیرمنتظره به‌درستی کار کند.

مثال LSP

تصور کنید یک ویجت پایه به نام MedicalHistoryTile داریم که یک ورودی سابقه پزشکی بیمار را با جزئیات کلی مانند تاریخ و عنوان نمایش می‌دهد. سپس می‌توانید یک زیرکلاس به نام AllergyHistoryTile ایجاد کنید که از MedicalHistoryTile ارث می‌برد اما اطلاعات خاص مربوط به آلرژی‌ها را نیز نمایش می‌دهد.

abstract class MedicalHistoryTile extends StatelessWidget {
  final String title;
  final DateTime date;

  MedicalHistoryTile(this.title, this.date);

  @override
  Widget build(BuildContext context) {
    return ListTile(
      title: Text(title),
      subtitle: Text(DateFormat.yMMMd().format(date)),
    );
  }
}

AllergyHistoryTile از MedicalHistoryTile ارث می‌برد و یک ویژگی allergen (ماده آلرژی‌زا) را اضافه می‌کند. از متد build کلاس پایه برای ساختار اصلی استفاده مجدد می‌کند و یک متد جدید getTrailingWidget را برای نمایش اطلاعات خاص آلرژی (رنگ قرمز برای تأکید) معرفی می‌کند.

class AllergyHistoryTile extends MedicalHistoryTile {
  final String allergen;

  AllergyHistoryTile(super.title, super.date, this.allergen);

  @override
  Widget build(BuildContext context) {
    return super.build(context); // Reuse base tile structure
  }

  Widget getTrailingWidget(BuildContext context) {
    return Text(
      "Allergen: $allergen",
      style: TextStyle(color: Colors.red),
    );
  }
}

MedicationHistoryTile از کلاس پایه ارث می‌برد و ویژگی‌های medication (دارو) و dosage (دوز) را اضافه می‌کند.

کل متد build را برای گنجاندن جزئیات دارو در ویجت انتهایی بازنویسی می‌کند و رویکردی متفاوت در مقایسه با AllergyHistoryTile نشان می‌دهد.

class MedicationHistoryTile extends MedicalHistoryTile {
  final String medication;
  final int dosage;

  MedicationHistoryTile(super.title, super.date, this.medication, this.dosage);

  @override
  Widget build(BuildContext context) {
    return ListTile(
      title: Text(title),
      subtitle: Text(DateFormat.yMMMd().format(date)),
      trailing: Text(
        "Medication: $medication ($dosage mg)",
      ),
    );
  }
}

حالا، استفاده از این ویجت‌ها را در برنامه خود در نظر بگیرید:

این کد در لیستی از اشیاء MedicalHistoryTile (شامل زیرکلاس‌ها) تکرار می‌شود.

از آنجا که هر دو زیرکلاس به اصل LSP پایبند هستند، می‌توانید از build(context) روی هر یک از آنها استفاده کنید و طبق انتظار کار خواهد کرد.

AllergyHistoryTile ویجت انتهایی قرمز خود را نمایش می‌دهد، در حالی که MedicationHistoryTile از ListTile سفارشی خود با جزئیات دارو استفاده می‌کند.

مزایای رویکرد LSP:

رفتار پایه سازگار: هر دو زیرکلاس از عملکرد کلاس پایه برای ساختار اصلی tile استفاده مجدد می‌کنند.

زیرکلاس‌ها تخصص اضافه می‌کنند: هر زیرکلاس اطلاعات خاص خود (جزئیات آلرژن یا دارو) را بدون تغییر رفتار کلاس پایه اضافه می‌کند.

استفاده چندریختی: می‌توانید همه نمونه‌ها را به عنوان اشیاء MedicalHistoryTile برای ساخت نمای لیست در نظر بگیرید و متد build مناسب بر اساس نوع زیرکلاس واقعی فراخوانی می‌شود.

LSP فقط در مورد متدها نیست. بلکه در مورد ویژگی‌ها و عملکرد کلی نیز صدق می‌کند. زیرکلاس‌ها باید رفتار کلاس پایه را گسترش یا تخصصی کنند، نه اینکه از هدف اصلی آن منحرف شوند.

ما یک ویجت پایه MedicalHistoryTile داریم که اطلاعات اولیه در مورد یک ورودی سابقه پزشکی را نمایش می‌دهد. سپس زیرکلاس‌هایی را برای انواع خاصی از ورودی‌ها، مانند AllergyHistoryTile و MedicationHistoryTile ایجاد می‌کنیم.

این کلاس پایه ساختار اصلی یک tile سابقه پزشکی را با عنوان و تاریخ تعریف می‌کند. انتزاعی است زیرا متد build را به طور کامل پیاده‌سازی نمی‌کند و به زیرکلاس‌ها اجازه می‌دهد محتوا را سفارشی کنند.

4. The Interface Segregation Principle (ISP)

اصل جداسازی رابط (Interface Segregation Principle یا ISP) بیان می‌کند که کلاینت‌ها (ویجت‌ها در فلاتر) نباید مجبور به وابستگی به متدهایی باشند که از آنها استفاده نمی‌کنند.

این اصل، ایجاد رابط‌های کوچکتر و خاص‌تر را به جای رابط‌های بزرگ و چندمنظوره ترویج می‌کند.

یکی از این سناریوها در برنامه ما جایی است که ما یک رابط واحد به نام HospitalService با متدهایی برای موارد زیر داریم:

  • دریافت اطلاعات بیمار
  • انجام اقدامات پزشکی
  • برنامه‌ریزی نوبت‌ها
  • صدور صورتحساب

این رویکرد، اصل ISP را نقض می‌کند زیرا ویجتی که مسئول نمایش اطلاعات بیمار است، ممکن است به قابلیت‌هایی مانند برنامه‌ریزی نوبت‌ها یا صدور صورتحساب نیازی نداشته باشد.

با این وجود، همچنان مجبور به وابستگی به کل رابط HospitalService خواهد بود.

راه‌حل با استفاده از ISP:

تعریف رابط‌های خاص:

  1. رابط‌های جداگانه برای هر قابلیت ایجاد کنید:
  • PatientInfoService برای بازیابی اطلاعات بیمار.
  • MedicalProcedureService برای انجام اقدامات پزشکی.
  • AppointmentService برای برنامه‌ریزی نوبت‌ها.
  • BillingService برای صدور صورتحساب.

به این ترتیب، هر ویجت فقط به رابط‌هایی وابسته خواهد بود که واقعاً به آنها نیاز دارد.

به عنوان مثال، ویجتی که اطلاعات بیمار را نمایش می‌دهد، فقط به PatientInfoService وابسته خواهد بود و نیازی به وابستگی به رابط‌های دیگر مانند AppointmentService یا BillingService نخواهد داشت.

این کار باعث کاهش وابستگی‌های غیرضروری و افزایش انعطاف‌پذیری و قابلیت نگهداری کد می‌شود.

abstract class PatientInfoService {
  Future<Patient> getPatient(int patientId);
}

abstract class MedicalProcedureService {
  Future<void> performProcedure(String procedureName, Patient patient);
}

abstract class AppointmentService {
  Future<Appointment> scheduleAppointment(DateTime dateTime, Patient patient, String doctorName);
}

abstract class BillingService {
  Future<Bill> generateBill(Patient patient, List<MedicalProcedure> procedures);
}

۲. پیاده‌سازی‌ها و نحوه استفاده:

این رابط‌ها را در کلاس‌های مشخصی که وظایف واقعی را انجام می‌دهند، پیاده‌سازی کنید.

سپس ویجت‌ها می‌توانند به رابط خاصی که به آن نیاز دارند، وابسته باشند.

class PatientInfoServiceImpl implements PatientInfoService {
  // Implementation for fetching patient information
}

class DisplayPatientInfo extends StatelessWidget {
  final int patientId;

  DisplayPatientInfo(this.patientId);

  @override
  Widget build(BuildContext context) {
    return FutureBuilder<Patient>(
      future: PatientInfoServiceImpl().getPatient(patientId),
      builder: (context, snapshot) {
        // Display patient information
      },
    );
  }
}

مزایای رویکرد LSP

  • بهبود قابلیت نگهداری کد: رابط‌های کوچکتر، درک و تغییر آنها آسان‌تر است.
  • کاهش وابستگی: ویجت‌ها فقط به وظایفی که به آنها نیاز دارند، وابسته هستند.
  • افزایش انعطاف‌پذیری: اضافه کردن وظایف جدید با رابط‌های جدید آسان‌تر است.
  • قابلیت تست‌پذیری: تست واحد وظایف خاص از طریق رابط‌های آنها آسان‌تر است.

5. The Dependency Inversion Principle (DIP)

اصل وارونگی وابستگی (DIP) بیان می‌کند که ماژول‌های سطح بالا (ویجت‌ها در فلاتر) نباید به ماژول‌های سطح پایین (پیاده‌سازی‌های مشخص) وابسته باشند.

هر دو باید به انتزاع‌ها (رابط‌ها یا کلاس‌های انتزاعی) وابسته باشند. این اصل، وابستگی ضعیف را تشویق می‌کند و قابلیت تست‌پذیری و نگهداری کد شما را بهبود می‌بخشد.

برنامه بیمارستان یک ویجت PatientDetails دارد که مستقیماً اطلاعات بیمار را از یک کلاس PatientRepository با استفاده از فراخوانی‌های شبکه دریافت می‌کند. این امر، وابستگی شدیدی بین ویجت و پیاده‌سازی repository ایجاد می‌کند.

چالش‌های وابستگی شدید:

  • تست: تست ویجت PatientDetails دشوار می‌شود زیرا شما باید فراخوانی‌های شبکه یا کل PatientRepository را mock کنید.
  • تغییرات: اگر نیاز به تغییر منبع داده (به عنوان مثال، از یک پایگاه داده محلی به یک API از راه دور) داشته باشید، باید منطق ویجت PatientDetails را تغییر دهید.

پیاده سازی تزریق وابستگی در فلاتر

معرفی انتزاع:

یک رابط PatientDataProvider ایجاد کنید که متدهایی را برای دریافت اطلاعات بیمار تعریف می‌کند.

abstract class PatientDataProvider {
  Future<Patient> getPatient(int patientId);
}

۲. پیاده‌سازی‌های مشخص:

کلاس‌های مشخصی مانند NetworkPatientRepository و LocalPatientRepository ایجاد کنید که PatientDataProvider را پیاده‌سازی می‌کنند. اینها دریافت داده از شبکه یا حافظه محلی را انجام می‌دهند.

class NetworkPatientRepository implements PatientDataProvider {
  // Implementation for fetching patient information from network
}

class LocalPatientRepository implements PatientDataProvider {
  // Implementation for fetching patient information from local storage (optional)
}

۳. تزریق وابستگی:

وابستگی PatientDataProvider را به سازنده ویجت PatientDetails تزریق کنید.

از یک چارچوب تزریق وابستگی (مانند Provider یا BLoC) برای مدیریت وابستگی‌ها در برنامه خود استفاده کنید.

class PatientDetails extends StatelessWidget {
  final int patientId;
  final PatientDataProvider patientDataProvider;

  PatientDetails(this.patientId, this.patientDataProvider);

  @override
  Widget build(BuildContext context) {
    return FutureBuilder<Patient>(
      future: patientDataProvider.getPatient(patientId),
      builder: (context, snapshot) {
        // Display patient information
      },
    );
  }
}

مزایای رویکرد DIP

  • وابستگی ضعیف: ویجت‌ها به پیاده‌سازی‌های خاص گره نخورده‌اند. شما می‌توانید به راحتی منبع داده را (به عنوان مثال، از NetworkPatientRepository یا LocalPatientRepository استفاده کنید) بدون تغییر منطق ویجت، تعویض کنید.
  • بهبود قابلیت تست‌پذیری: شما می‌توانید به راحتی رابط PatientDataProvider را در طول تست‌های واحد برای ویجت PatientDetails mock کنید.
  • افزایش قابلیت نگهداری: کد مدولارتر و تغییر آن در آینده آسان‌تر می‌شود.

بزرگترین چالش‌های شما با SOLID چیست؟ نظرات خود را در بخش نظرات به اشتراک بگذارید!

مشاهده منبع

دیدگاه‌ها (0)

    دیدگاه خود را بنویسید

    ایمیل شما نمایش داده نمی‌شود. دیدگاه پس از تأیید نمایش داده می‌شود.